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-notification-service/src/test/java/notification/controller/NotificationControllerTest.java
|
package notification.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import notification.entity.NotifyInfo;
import notification.service.NotificationService;
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 org.springframework.http.MediaType;
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;
@RunWith(JUnit4.class)
public class NotificationControllerTest {
@InjectMocks
private NotificationController notificationController;
@Mock
private NotificationService service;
private MockMvc mockMvc;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(notificationController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/notifyservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Notification Service ] !"));
}
@Test
public void testPreserveSuccess() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.when(service.preserveSuccess(Mockito.any(NotifyInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(true);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/notifyservice/notification/preserve_success").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertTrue(JSONObject.parseObject(result, Boolean.class));
}
@Test
public void testOrderCreateSuccess() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.when(service.orderCreateSuccess(Mockito.any(NotifyInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(true);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/notifyservice/notification/order_create_success").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertTrue(JSONObject.parseObject(result, Boolean.class));
}
@Test
public void testOrderChangedSuccess() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.when(service.orderChangedSuccess(Mockito.any(NotifyInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(true);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/notifyservice/notification/order_changed_success").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertTrue(JSONObject.parseObject(result, Boolean.class));
}
@Test
public void testOrderCancelSuccess() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.when(service.orderCancelSuccess(Mockito.any(NotifyInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(true);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/notifyservice/notification/order_cancel_success").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertTrue(JSONObject.parseObject(result, Boolean.class));
}
}
| 4,357 | 46.89011 | 189 |
java
|
train-ticket
|
train-ticket-master/ts-notification-service/src/test/java/notification/service/NotificationServiceImplTest.java
|
package notification.service;
import notification.entity.Mail;
import notification.entity.NotifyInfo;
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;
@RunWith(JUnit4.class)
public class NotificationServiceImplTest {
@InjectMocks
private NotificationServiceImpl notificationServiceImpl;
@Mock
private MailService mailService;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testPreserveSuccess1() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doNothing().doThrow(new RuntimeException()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.preserveSuccess(info, headers);
Assert.assertTrue(result);
}
@Test
public void testPreserveSuccess2() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doThrow(new Exception()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.preserveSuccess(info, headers);
Assert.assertFalse(result);
}
@Test
public void testOrderCreateSuccess1() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doNothing().doThrow(new RuntimeException()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.orderCreateSuccess(info, headers);
Assert.assertTrue(result);
}
@Test
public void testOrderCreateSuccess2() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doThrow(new Exception()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.orderCreateSuccess(info, headers);
Assert.assertFalse(result);
}
@Test
public void testOrderChangedSuccess1() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doNothing().doThrow(new RuntimeException()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.orderChangedSuccess(info, headers);
Assert.assertTrue(result);
}
@Test
public void testOrderChangedSuccess2() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doThrow(new Exception()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.orderChangedSuccess(info, headers);
Assert.assertFalse(result);
}
@Test
public void testOrderCancelSuccess1() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doNothing().doThrow(new RuntimeException()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.orderCancelSuccess(info, headers);
Assert.assertTrue(result);
}
@Test
public void testOrderCancelSuccess2() throws Exception {
NotifyInfo info = new NotifyInfo();
Mockito.doThrow(new Exception()).when(mailService).sendEmail(Mockito.any(Mail.class), Mockito.anyString());
boolean result = notificationServiceImpl.orderCancelSuccess(info, headers);
Assert.assertFalse(result);
}
}
| 3,679 | 36.938144 | 134 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/OrderOtherApplication.java
|
package other;
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 OrderOtherApplication {
public static void main(String[] args) {
SpringApplication.run(OrderOtherApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,188 | 31.135135 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/config/SecurityConfig.java
|
package other.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 orderOther = "/api/v1/orderOtherService/orderOther";
/**
* 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/orderOtherService/orderOther/**").permitAll()
.antMatchers(HttpMethod.POST, orderOther).hasAnyRole(admin, "USER")
.antMatchers(HttpMethod.PUT, orderOther).hasAnyRole(admin, "USER")
.antMatchers(HttpMethod.DELETE, orderOther).hasAnyRole(admin, "USER")
.antMatchers(HttpMethod.POST, "/api/v1/orderOtherService/orderOther/admin").hasAnyRole(admin)
.antMatchers(HttpMethod.PUT, "/api/v1/orderOtherService/orderOther/admin").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,855 | 41.373626 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/controller/OrderOtherController.java
|
package other.controller;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.util.StringUtils;
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 other.entity.Order;
import other.entity.QueryInfo;
import other.service.OrderOtherService;
import java.util.Date;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/orderOtherService")
public class OrderOtherController {
@Autowired
private OrderOtherService orderService;
private static final Logger LOGGER = LoggerFactory.getLogger(OrderOtherController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ Order Other Service ] !";
}
/***************************For Normal Use***************************/
@PostMapping(value = "/orderOther/tickets")
public HttpEntity getTicketListByDateAndTripId(@RequestBody Seat seatRequest, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[getSoldTickets][Get Sold Ticket][Travel Date: {}]", seatRequest.getTravelDate().toString());
return ok(orderService.getSoldTickets(seatRequest, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/orderOther")
public HttpEntity createNewOrder(@RequestBody Order createOrder, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[create][Create Order][from {} to {} at {}]", createOrder.getFrom(), createOrder.getTo(), createOrder.getTravelDate());
return ok(orderService.create(createOrder, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/orderOther/admin")
public HttpEntity addcreateNewOrder(@RequestBody Order order, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[addNewOrder][Add new order][OrderId: {}]", order.getId());
return ok(orderService.addNewOrder(order, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/orderOther/query")
public HttpEntity queryOrders(@RequestBody QueryInfo qi,
@RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[queryOrders][Query Orders][for LoginId :{}]", qi.getLoginId());
return ok(orderService.queryOrders(qi, qi.getLoginId(), headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/orderOther/refresh")
public HttpEntity queryOrdersForRefresh(@RequestBody QueryInfo qi,
@RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[queryOrdersForRefresh][Query Orders][for LoginId:{}]", qi.getLoginId());
return ok(orderService.queryOrdersForRefresh(qi, qi.getLoginId(), headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/orderOther/{travelDate}/{trainNumber}")
public HttpEntity calculateSoldTicket(@PathVariable String travelDate, @PathVariable String trainNumber,
@RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[queryAlreadySoldOrders][Calculate Sold Tickets][Date: {} TrainNumber: {}]", travelDate, trainNumber);
return ok(orderService.queryAlreadySoldOrders(StringUtils.String2Date(travelDate), trainNumber, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/orderOther/price/{orderId}")
public HttpEntity getOrderPrice(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[getOrderPrice][Get Order Price][Order Id: {}]", orderId);
return ok(orderService.getOrderPrice(orderId, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/orderOther/orderPay/{orderId}")
public HttpEntity payOrder(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[payOrder][Pay Order][Order Id: {}]", orderId);
return ok(orderService.payOrder(orderId, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/orderOther/{orderId}")
public HttpEntity getOrderById(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[getOrderById][Get Order By Id][Order Id: {}]", orderId);
return ok(orderService.getOrderById(orderId, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/orderOther/status/{orderId}/{status}")
public HttpEntity modifyOrder(@PathVariable String orderId, @PathVariable int status, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[modifyOrder][Modify Order Status][Order Id: {}]", orderId);
return ok(orderService.modifyOrder(orderId, status, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/orderOther/security/{checkDate}/{accountId}")
public HttpEntity securityInfoCheck(@PathVariable String checkDate, @PathVariable String accountId,
@RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[checkSecurityAboutOrder][Security Info Get][CheckDate:{} , AccountId:{}]",checkDate,accountId);
return ok(orderService.checkSecurityAboutOrder(StringUtils.String2Date(checkDate), accountId, headers));
}
@CrossOrigin(origins = "*")
@PutMapping(path = "/orderOther")
public HttpEntity saveOrderInfo(@RequestBody Order orderInfo,
@RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[saveChanges][Save Order Info][OrderId:{}]",orderInfo.getId());
return ok(orderService.saveChanges(orderInfo, headers));
}
@CrossOrigin(origins = "*")
@PutMapping(path = "/orderOther/admin")
public HttpEntity updateOrder(@RequestBody Order order, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[updateOrder][Update Order][OrderId: {}]", order.getId());
return ok(orderService.updateOrder(order, headers));
}
@CrossOrigin(origins = "*")
@DeleteMapping(path = "/orderOther/{orderId}")
public HttpEntity deleteOrder(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[deleteOrder][Delete Order][OrderId: {}]", orderId);
return ok(orderService.deleteOrder(orderId, headers));
}
/***************For super admin(Single Service Test*******************/
@CrossOrigin(origins = "*")
@GetMapping(path = "/orderOther")
public HttpEntity findAllOrder(@RequestHeader HttpHeaders headers) {
OrderOtherController.LOGGER.info("[getAllOrders][Find All Order]");
return ok(orderService.getAllOrders(headers));
}
}
| 7,014 | 44.258065 | 161 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/entity/Order.java
|
package other.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import edu.fudan.common.entity.OrderStatus;
import edu.fudan.common.entity.SeatClass;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import lombok.ToString;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.util.Date;
/**
* @author fdse
*/
@Data
@Table(name = "orders_other")
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
@ToString
@JsonIgnoreProperties(ignoreUnknown = true)
public class Order {
@Id
@Column(length = 36)
@GeneratedValue(generator = "jpa-uuid")
private String id;
private String boughtDate;
private String travelDate;
private String travelTime;
/**
* Which Account Bought it
*/
@Column(length = 36)
private String accountId;
/**
* Tickets bought for whom....
*/
private String contactsName;
private int documentType;
private String contactsDocumentNumber;
private String trainNumber;
private int coachNumber;
private int seatClass;
private String seatNumber;
@Column(name = "from_station")
private String from;
@Column(name = "to_station")
private String to;
private int status;
private String price;
public Order(){
boughtDate = StringUtils.Date2String(new Date(System.currentTimeMillis()));
travelDate = StringUtils.Date2String(new Date(123456789));
trainNumber = "G1235";
coachNumber = 5;
seatClass = SeatClass.FIRSTCLASS.getCode();
seatNumber = "1";
from = "shanghai";
to = "taiyuan";
status = OrderStatus.PAID.getCode();
price = "0.0";
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Order other = (Order) obj;
return getBoughtDate().equals(other.getBoughtDate())
&& getBoughtDate().equals(other.getTravelDate())
&& getTravelTime().equals(other.getTravelTime())
&& accountId .equals( other.getAccountId() )
&& contactsName.equals(other.getContactsName())
&& contactsDocumentNumber.equals(other.getContactsDocumentNumber())
&& documentType == other.getDocumentType()
&& trainNumber.equals(other.getTrainNumber())
&& coachNumber == other.getCoachNumber()
&& seatClass == other.getSeatClass()
&& seatNumber .equals(other.getSeatNumber())
&& from.equals(other.getFrom())
&& to.equals(other.getTo())
&& status == other.getStatus()
&& price.equals(other.price);
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + (id == null ? 0 : id.hashCode());
return result;
}
}
| 3,114 | 24.958333 | 83 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/entity/OrderAlterInfo.java
|
package other.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@AllArgsConstructor
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class OrderAlterInfo {
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String accountId;
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String previousOrderId;
private String loginToken;
private Order newOrderInfo;
public OrderAlterInfo(){
newOrderInfo = new Order();
}
}
| 734 | 20 | 81 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/entity/QueryInfo.java
|
package other.entity;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import java.util.Date;
/**
* @author fdse
*/
@Data
public class QueryInfo {
/**
* account id
*/
private String loginId;
private String travelDateStart;
private String travelDateEnd;
private String boughtDateStart;
private String boughtDateEnd;
private int state;
private boolean enableTravelDateQuery;
private boolean enableBoughtDateQuery;
private boolean enableStateQuery;
public QueryInfo() {
//Default Constructor
}
public void enableTravelDateQuery(String startTime, String endTime) {
enableTravelDateQuery = true;
travelDateStart = startTime;
travelDateEnd = endTime;
}
public void disableTravelDateQuery() {
enableTravelDateQuery = false;
travelDateStart = null;
travelDateEnd = null;
}
public void enableBoughtDateQuery(String startTime, String endTime) {
enableBoughtDateQuery = true;
boughtDateStart = startTime;
boughtDateEnd = endTime;
}
public void disableBoughtDateQuery() {
enableBoughtDateQuery = false;
boughtDateStart = null;
boughtDateEnd = null;
}
public void enableStateQuery(int targetStatus) {
enableStateQuery = true;
state = targetStatus;
}
public void disableStateQuery() {
enableTravelDateQuery = false;
state = -1;
}
}
| 1,494 | 19.479452 | 73 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/init/InitData.java
|
package other.init;
import edu.fudan.common.entity.OrderStatus;
import edu.fudan.common.util.StringUtils;
import org.apache.tomcat.jni.Time;
import other.entity.Order;
import edu.fudan.common.entity.SeatClass;
import other.service.OrderOtherService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.UUID;
/**
* @author fdse
*/
@Component
public class InitData implements CommandLineRunner {
@Autowired
OrderOtherService service;
@Override
public void run(String... args)throws Exception{
Order order1 = new Order();
order1.setAccountId("4d2a46c7-71cb-4cf1-b5bb-b68406d9da6f");
order1.setCoachNumber(5);
order1.setContactsDocumentNumber("Test");
order1.setContactsName("Test");
order1.setDocumentType(1);
order1.setFrom("shanghai");
order1.setId("4d2a46c7-71cb-4cf1-c5bb-b68406d9da6f");
order1.setPrice("100");
order1.setSeatClass(SeatClass.FIRSTCLASS.getCode());
order1.setSeatNumber("6A");
order1.setStatus(OrderStatus.PAID.getCode());
order1.setTo("taiyuan");
order1.setTrainNumber("K1235");
order1.setTravelDate("2022-10-01 00:00:00"); //NOSONAR
order1.setTravelTime("2022-10-01 00:00:00"); //NOSONAR
service.create(order1,null);
}
}
| 1,456 | 29.354167 | 68 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/repository/OrderOtherRepository.java
|
package other.repository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import other.entity.Order;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.Date;
import java.util.Optional;
import java.util.UUID;
/**
* @author fdse
*/
@Repository
public interface OrderOtherRepository extends CrudRepository<Order, String> {
/**
* find order by id
*
* @param id id
* @return Order
*/
// @Query("{ 'id': ?0 }")
@Override
Optional<Order> findById(String id);
/**
* find all orders
*
* @return ArrayList<Order>
*/
@Override
ArrayList<Order> findAll();
/**
* find orders by account id
*
* @param accountId account id
* @return ArrayList<Order>
*/
// @Query("{ 'accountId' : ?0 }")
ArrayList<Order> findByAccountId(String accountId);
/**
* find orders by travel date and train number
*
* @param travelDate travel date
* @param trainNumber train number
* @return ArrayList<Order>
*/
// @Query("{ 'travelDate' : ?0 , trainNumber : ?1 }")
ArrayList<Order> findByTravelDateAndTrainNumber(String travelDate, String trainNumber);
/**
* delete order by id
*
* @param id id
* @return null
*/
@Override
void deleteById(String id);
}
| 1,418 | 21.171875 | 91 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/service/OrderOtherService.java
|
package other.service;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import other.entity.Order;
import other.entity.QueryInfo;
import other.entity.OrderAlterInfo;
import java.util.Date;
/**
* @author fdse
*/
public interface OrderOtherService {
Response findOrderById(String id, HttpHeaders headers);
Response create(Order newOrder, HttpHeaders headers);
Response updateOrder(Order order, HttpHeaders headers);
Response saveChanges(Order order, HttpHeaders headers);
Response cancelOrder(String accountId, String orderId, HttpHeaders headers);
Response addNewOrder(Order order, HttpHeaders headers);
Response deleteOrder(String orderId, HttpHeaders headers);
Response getOrderById(String orderId, HttpHeaders headers);
Response payOrder(String orderId, HttpHeaders headers);
Response getOrderPrice(String orderId, HttpHeaders headers);
Response modifyOrder(String orderId, int status, HttpHeaders headers);
Response getAllOrders(HttpHeaders headers);
Response getSoldTickets(Seat seatRequest, HttpHeaders headers);
Response queryOrders(QueryInfo qi, String accountId, HttpHeaders headers);
Response queryOrdersForRefresh(QueryInfo qi, String accountId, HttpHeaders headers);
Response alterOrder(OrderAlterInfo oai, HttpHeaders headers);
Response queryAlreadySoldOrders(Date travelDate, String trainNumber, HttpHeaders headers);
Response checkSecurityAboutOrder(Date checkDate, String accountId, HttpHeaders headers);
void initOrder(Order order, HttpHeaders headers);
}
| 1,645 | 28.392857 | 94 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/main/java/other/service/OrderOtherServiceImpl.java
|
package other.service;
import edu.fudan.common.entity.*;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.web.client.RestTemplate;
import other.entity.*;
import other.entity.Order;
import other.entity.OrderAlterInfo;
import other.repository.OrderOtherRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* @author fdse
*/
@Service
public class OrderOtherServiceImpl implements OrderOtherService {
@Autowired
private OrderOtherRepository orderOtherRepository;
@Autowired
private RestTemplate restTemplate;
private static final Logger LOGGER = LoggerFactory.getLogger(OrderOtherServiceImpl.class);
@Autowired
private DiscoveryClient discoveryClient;
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
// @Value("${station-service.url}")
// String station_service_url;
String success = "Success";
String orderNotFound = "Order Not Found";
@Override
public Response getSoldTickets(Seat seatRequest, HttpHeaders headers) {
ArrayList<Order> list = orderOtherRepository.findByTravelDateAndTrainNumber(seatRequest.getTravelDate(),
seatRequest.getTrainNumber());
if (list != null && !list.isEmpty()) {
Set ticketSet = new HashSet();
for (Order tempOrder : list) {
Ticket ticket = new Ticket();
ticket.setSeatNo(Integer.parseInt(tempOrder.getSeatNumber()));
ticket.setStartStation(tempOrder.getFrom());
ticket.setDestStation(tempOrder.getTo());
ticketSet.add(ticket);
}
LeftTicketInfo leftTicketInfo = new LeftTicketInfo();
leftTicketInfo.setSoldTickets(ticketSet);
OrderOtherServiceImpl.LOGGER.info("[getSoldTickets][Left ticket info][info is: {}]", leftTicketInfo.toString());
return new Response<>(1, success, leftTicketInfo);
} else {
OrderOtherServiceImpl.LOGGER.warn("[getSoldTickets][Seat][No content][seat from date: {}, train number: {}",seatRequest.getTravelDate(),seatRequest.getTrainNumber());
return new Response<>(0, "Seat is Null.", null);
}
}
@Override
public Response findOrderById(String id, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(id);
if (!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.warn("[findOrderById][Find Order By Id Fail][No content][id: {}]",id);
return new Response<>(0, "No Content by this id", null);
} else {
Order order = op.get();
OrderOtherServiceImpl.LOGGER.info("[findOrderById][Find Order By Id Success][id: {}]",id);
return new Response<>(1, success, order);
}
}
@Override
public Response create(Order order, HttpHeaders headers) {
OrderOtherServiceImpl.LOGGER.info("[create][Create Order][Ready Create Order]");
ArrayList<Order> accountOrders = orderOtherRepository.findByAccountId(order.getAccountId());
if (accountOrders.contains(order)) {
OrderOtherServiceImpl.LOGGER.error("[create][Order Create Fail][Order already exists][OrderId: {}]", order.getId());
return new Response<>(0, "Order already exist", order);
} else {
order.setId(UUID.randomUUID().toString());
order=orderOtherRepository.save(order);
OrderOtherServiceImpl.LOGGER.info("[create][Order Create Success][OrderId:{},Price: {}]",order.getId(),order.getPrice());
return new Response<>(1, success, order);
}
}
@Override
public void initOrder(Order order, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(order.getId());
if (!op.isPresent()) {
orderOtherRepository.save(order);
OrderOtherServiceImpl.LOGGER.info("[initOrder][Init Order Success][OrderId: {}]", order.getId());
} else {
Order orderTemp = op.get();
OrderOtherServiceImpl.LOGGER.error("[initOrder][Init Order Fail][Order Already Exists][OrderId: {}]", order.getId());
}
}
@Override
public Response alterOrder(OrderAlterInfo oai, HttpHeaders headers) {
String oldOrderId = oai.getPreviousOrderId();
if (!orderOtherRepository.findById(oldOrderId).isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[alterOrder][Alter Order Fail][Order do not exist][OrderId: {}]", oldOrderId);
return new Response<>(0, "Old Order Does Not Exists", null);
}
Order oldOrder = orderOtherRepository.findById(oldOrderId).get();
oldOrder.setStatus(OrderStatus.CANCEL.getCode());
saveChanges(oldOrder, headers);
Order newOrder = oai.getNewOrderInfo();
newOrder.setId(UUID.randomUUID().toString());
Response cor = create(oai.getNewOrderInfo(), headers);
if (cor.getStatus() == 1) {
OrderOtherServiceImpl.LOGGER.info("[alterOrder][Alter Order Success][newOrderId:{}]",newOrder.getId());
return new Response<>(1, "Alter Order Success", newOrder);
} else {
OrderOtherServiceImpl.LOGGER.error("[alterOrder][Alter Order Fail][Create new order fail][newOrderId: {}]", newOrder.getId());
return new Response<>(0, cor.getMsg(), null);
}
}
@Override
public Response<ArrayList<Order>> queryOrders(QueryInfo qi, String accountId, HttpHeaders headers) {
//1.Get all orders of the user
ArrayList<Order> list = orderOtherRepository.findByAccountId(accountId);
OrderOtherServiceImpl.LOGGER.info("[queryOrders][Step 1][Get Orders Number of Account][size: {}]", list.size());
//2.Check is these orders fit the requirement/
if (qi.isEnableStateQuery() || qi.isEnableBoughtDateQuery() || qi.isEnableTravelDateQuery()) {
ArrayList<Order> finalList = new ArrayList<>();
for (Order tempOrder : list) {
boolean statePassFlag = false;
boolean boughtDatePassFlag = false;
boolean travelDatePassFlag = false;
//3.Check order state requirement.
if (qi.isEnableStateQuery()) {
if (tempOrder.getStatus() != qi.getState()) {
statePassFlag = false;
} else {
statePassFlag = true;
}
} else {
statePassFlag = true;
}
OrderOtherServiceImpl.LOGGER.info("[queryOrders][Step 2][Check Status Fits End]");
//4.Check order travel date requirement.
Date boughtDate = StringUtils.String2Date(tempOrder.getBoughtDate());
Date travelDate = StringUtils.String2Date(tempOrder.getTravelDate());
Date travelDateEnd = StringUtils.String2Date(qi.getTravelDateEnd());
Date boughtDateStart = StringUtils.String2Date(qi.getBoughtDateStart());
Date boughtDateEnd = StringUtils.String2Date(qi.getBoughtDateEnd());
if (qi.isEnableTravelDateQuery()) {
if (travelDate.before(travelDateEnd) &&
travelDate.after(boughtDateStart)) {
travelDatePassFlag = true;
} else {
travelDatePassFlag = false;
}
} else {
travelDatePassFlag = true;
}
OrderOtherServiceImpl.LOGGER.info("[queryOrders][Step 2][Check Travel Date End]");
//5.Check order bought date requirement.
if (qi.isEnableBoughtDateQuery()) {
if (boughtDate.before(boughtDateEnd) &&
boughtDate.after(boughtDateStart)) {
boughtDatePassFlag = true;
} else {
boughtDatePassFlag = false;
}
} else {
boughtDatePassFlag = true;
}
OrderOtherServiceImpl.LOGGER.info("[queryOrders][Step 2][Check Bought Date End]");
//6.check if all requirement fits.
if (statePassFlag && boughtDatePassFlag && travelDatePassFlag) {
finalList.add(tempOrder);
}
OrderOtherServiceImpl.LOGGER.info("[queryOrders][Step 2][Check All Requirement End]");
}
OrderOtherServiceImpl.LOGGER.info("[queryOrders][Get order num][size:{}]", finalList.size());
return new Response<>(1, "Get order num", finalList);
} else {
OrderOtherServiceImpl.LOGGER.warn("[queryOrders][Orders don't fit the requirement][loginId: {}]", qi.getLoginId());
return new Response<>(1, "Get order num", list);
}
}
@Override
public Response queryOrdersForRefresh(QueryInfo qi, String accountId, HttpHeaders headers) {
ArrayList<Order> orders = queryOrders(qi, accountId, headers).getData();
ArrayList<String> stationIds = new ArrayList<>();
for (Order order : orders) {
stationIds.add(order.getFrom());
stationIds.add(order.getTo());
}
for (int i = 0; i < orders.size(); i++) {
orders.get(i).setFrom(stationIds.get(i * 2));
orders.get(i).setTo(stationIds.get(i * 2 + 1));
}
return new Response<>(1, success, orders);
}
public List<String> queryForStationId(List<String> ids, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(ids, null);
String station_service_url=getServiceUrl("ts-station-service");
ResponseEntity<Response<List<String>>> re = restTemplate.exchange(
station_service_url + "/api/v1/stationservice/stations/namelist",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<List<String>>>() {
});
OrderOtherServiceImpl.LOGGER.info("[queryForStationId][Stations name list][Name List is : {}]", re.getBody().toString());
return re.getBody().getData();
}
@Override
public Response saveChanges(Order order, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(order.getId());
if (!op.isPresent() ) {
OrderOtherServiceImpl.LOGGER.error("[saveChanges][Modify Order Fail][Order not found][OrderId: {}]", order.getId());
return new Response<>(0, orderNotFound, null);
} else {
Order oldOrder = op.get();
oldOrder.setAccountId(order.getAccountId());
oldOrder.setBoughtDate(order.getBoughtDate());
oldOrder.setTravelDate(order.getTravelDate());
oldOrder.setTravelTime(order.getTravelTime());
oldOrder.setSeatClass(order.getSeatClass());
oldOrder.setCoachNumber(order.getCoachNumber());
oldOrder.setSeatNumber(order.getSeatNumber());
oldOrder.setTo(order.getTo());
oldOrder.setFrom(order.getFrom());
oldOrder.setStatus(order.getStatus());
oldOrder.setTrainNumber(order.getTrainNumber());
oldOrder.setPrice(order.getPrice());
oldOrder.setContactsName(order.getContactsName());
oldOrder.setDocumentType(order.getDocumentType());
oldOrder.setContactsDocumentNumber(order.getContactsDocumentNumber());
orderOtherRepository.save(oldOrder);
OrderOtherServiceImpl.LOGGER.info("[saveChanges][Modify Order Success][OrderId: {}]",order.getId());
return new Response<>(1, success, oldOrder);
}
}
@Override
public Response cancelOrder(String accountId, String orderId, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(orderId);
if (!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[cancelOrder][Cancel Order Fail][Order not found][OrderId: {}]", orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order oldOrder = op.get();
oldOrder.setStatus(OrderStatus.CANCEL.getCode());
orderOtherRepository.save(oldOrder);
OrderOtherServiceImpl.LOGGER.info("[cancelOrder][Cancel Order Success][OrderId: {}]",oldOrder.getId());
return new Response<>(1, success, oldOrder);
}
}
@Override
public Response queryAlreadySoldOrders(Date travelDate, String trainNumber, HttpHeaders headers) {
ArrayList<Order> orders = orderOtherRepository.findByTravelDateAndTrainNumber(StringUtils.Date2String(travelDate), trainNumber);
SoldTicket cstr = new SoldTicket();
cstr.setTravelDate(travelDate);
cstr.setTrainNumber(trainNumber);
OrderOtherServiceImpl.LOGGER.info("[queryAlreadySoldOrders][Calculate Sold Ticket][Get Orders Number: {}]", orders.size());
for (Order order : orders) {
if (order.getStatus() >= OrderStatus.CHANGE.getCode()) {
continue;
}
if (order.getSeatClass() == SeatClass.NONE.getCode()) {
cstr.setNoSeat(cstr.getNoSeat() + 1);
} else if (order.getSeatClass() == SeatClass.BUSINESS.getCode()) {
cstr.setBusinessSeat(cstr.getBusinessSeat() + 1);
} else if (order.getSeatClass() == SeatClass.FIRSTCLASS.getCode()) {
cstr.setFirstClassSeat(cstr.getFirstClassSeat() + 1);
} else if (order.getSeatClass() == SeatClass.SECONDCLASS.getCode()) {
cstr.setSecondClassSeat(cstr.getSecondClassSeat() + 1);
} else if (order.getSeatClass() == SeatClass.HARDSEAT.getCode()) {
cstr.setHardSeat(cstr.getHardSeat() + 1);
} else if (order.getSeatClass() == SeatClass.SOFTSEAT.getCode()) {
cstr.setSoftSeat(cstr.getSoftSeat() + 1);
} else if (order.getSeatClass() == SeatClass.HARDBED.getCode()) {
cstr.setHardBed(cstr.getHardBed() + 1);
} else if (order.getSeatClass() == SeatClass.SOFTBED.getCode()) {
cstr.setSoftBed(cstr.getSoftBed() + 1);
} else if (order.getSeatClass() == SeatClass.HIGHSOFTBED.getCode()) {
cstr.setHighSoftBed(cstr.getHighSoftBed() + 1);
} else {
OrderOtherServiceImpl.LOGGER.info("[queryAlreadySoldOrders][Calculate Sold Tickets][Seat class not exists][Order ID: {}]", order.getId());
}
}
return new Response<>(1, success, cstr);
}
@Override
public Response getAllOrders(HttpHeaders headers) {
ArrayList<Order> orders = orderOtherRepository.findAll();
if (orders == null) {
OrderOtherServiceImpl.LOGGER.warn("[getAllOrders][Find all orders warn][{}]","No content");
return new Response<>(0, "No Content", null);
} else {
OrderOtherServiceImpl.LOGGER.info("[getAllOrders][Find all orders Success][size:{}]",orders.size());
return new Response<>(1, success, orders);
}
}
@Override
public Response modifyOrder(String orderId, int status, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(orderId);
if (!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[modifyOrder][Modify order Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order order = op.get();
order.setStatus(status);
orderOtherRepository.save(order);
OrderOtherServiceImpl.LOGGER.info("[modifyOrder][Modify order Success][OrderId: {}]",orderId);
return new Response<>(1, success, order);
}
}
@Override
public Response getOrderPrice(String orderId, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(orderId);
if (!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[getOrderPrice][Get order price Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, "-1.0");
} else {
Order order = op.get();
OrderOtherServiceImpl.LOGGER.info("[getOrderPrice][Get Order Price Success][OrderId:{} , Price: {}]", orderId,order.getPrice());
return new Response<>(1, success, order.getPrice());
}
}
@Override
public Response payOrder(String orderId, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(orderId);
if (!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[payOrder][Pay order Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order order = op.get();
order.setStatus(OrderStatus.PAID.getCode());
orderOtherRepository.save(order);
OrderOtherServiceImpl.LOGGER.info("[payOrder][Pay order Success][OrderId: {}]",orderId);
return new Response<>(1, success, order);
}
}
@Override
public Response getOrderById(String orderId, HttpHeaders headers) {
Optional<Order> op = orderOtherRepository.findById(orderId);
if(!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[getOrderById][Get Order By ID Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order order = op.get();
OrderOtherServiceImpl.LOGGER.info("[getOrderById][Get Order By ID Success][OrderId: {}]",orderId);
return new Response<>(1, success, order);
}
}
@Override
public Response checkSecurityAboutOrder(Date dateFrom, String accountId, HttpHeaders headers) {
OrderSecurity result = new OrderSecurity();
ArrayList<Order> orders = orderOtherRepository.findByAccountId(accountId);
int countOrderInOneHour = 0;
int countTotalValidOrder = 0;
Calendar ca = Calendar.getInstance();
ca.setTime(dateFrom);
ca.add(Calendar.HOUR_OF_DAY, -1);
dateFrom = ca.getTime();
for (Order order : orders) {
if (order.getStatus() == OrderStatus.NOTPAID.getCode() ||
order.getStatus() == OrderStatus.PAID.getCode() ||
order.getStatus() == OrderStatus.COLLECTED.getCode()) {
countTotalValidOrder += 1;
}
Date boughtDate = StringUtils.String2Date(order.getBoughtDate());
if (boughtDate.after(dateFrom)) {
countOrderInOneHour += 1;
}
}
result.setOrderNumInLastOneHour(countOrderInOneHour);
result.setOrderNumOfValidOrder(countTotalValidOrder);
return new Response<>(1, success, result);
}
@Override
public Response deleteOrder(String orderId, HttpHeaders headers) {
String orderUuid = UUID.fromString(orderId).toString();
Optional<Order> op = orderOtherRepository.findById(orderUuid);
if(!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[deleteOrder][Delete order Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, "Order Not Exist.", null);
} else {
Order order = op.get();
orderOtherRepository.deleteById(orderUuid);
OrderOtherServiceImpl.LOGGER.info("[deleteOrder][Delete order Success][OrderId: {}]",orderId);
return new Response<>(1, success, orderUuid);
}
}
@Override
public Response addNewOrder(Order order, HttpHeaders headers) {
OrderOtherServiceImpl.LOGGER.info("[addNewOrder][Admin Add Order][Ready to Add Order]");
ArrayList<Order> accountOrders = orderOtherRepository.findByAccountId(order.getAccountId());
if (accountOrders.contains(order)) {
OrderOtherServiceImpl.LOGGER.error("[addNewOrder][Admin Add Order Fail][Order already exists][OrderId: {}]",order.getId());
return new Response<>(0, "Order already exist", null);
} else {
order.setId(UUID.randomUUID().toString());
orderOtherRepository.save(order);
OrderOtherServiceImpl.LOGGER.info("[addNewOrder][Admin Add Order Success][OrderId:{} , Price:{}]",order.getId(),order.getPrice());
return new Response<>(1, success, order);
}
}
@Override
public Response updateOrder(Order order, HttpHeaders headers) {
LOGGER.info("[updateOrder][Admin Update Order][Order Info:{}]",order.toString());
Optional<Order> op = orderOtherRepository.findById(order.getId());
if(!op.isPresent()) {
OrderOtherServiceImpl.LOGGER.error("[updateOrder][Admin Update Order Fail][Order not found][OrderId: {}]",order.getId());
return new Response<>(0, orderNotFound, null);
} else {
Order oldOrder = op.get();
//OrderOtherServiceImpl.LOGGER.info("{}", oldOrder.toString());
oldOrder.setAccountId(order.getAccountId());
oldOrder.setBoughtDate(order.getBoughtDate());
oldOrder.setTravelDate(order.getTravelDate());
oldOrder.setTravelTime(order.getTravelTime());
oldOrder.setCoachNumber(order.getCoachNumber());
oldOrder.setSeatClass(order.getSeatClass());
oldOrder.setSeatNumber(order.getSeatNumber());
oldOrder.setFrom(order.getFrom());
oldOrder.setTo(order.getTo());
oldOrder.setStatus(order.getStatus());
oldOrder.setTrainNumber(order.getTrainNumber());
oldOrder.setPrice(order.getPrice());
oldOrder.setContactsName(order.getContactsName());
oldOrder.setContactsDocumentNumber(order.getContactsDocumentNumber());
oldOrder.setDocumentType(order.getDocumentType());
orderOtherRepository.save(oldOrder);
OrderOtherServiceImpl.LOGGER.info("[updateOrder][Admin Update Order Success][OrderId:{}]",oldOrder.getId());
return new Response<>(1, success, oldOrder);
}
}
}
| 22,880 | 46.868201 | 178 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/test/java/other/controller/OrderOtherControllerTest.java
|
package other.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.entity.Seat;
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 other.entity.Order;
import other.entity.QueryInfo;
import other.service.OrderOtherService;
import java.util.Date;
@RunWith(JUnit4.class)
public class OrderOtherControllerTest {
@InjectMocks
private OrderOtherController orderOtherController;
@Mock
private OrderOtherService orderService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(orderOtherController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Order Other Service ] !"));
}
@Test
public void testGetTicketListByDateAndTripId() throws Exception {
Seat seatRequest = new Seat();
Mockito.when(orderService.getSoldTickets(Mockito.any(Seat.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(seatRequest);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderOtherService/orderOther/tickets").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreateNewOrder() throws Exception {
Order createOrder = new Order();
Mockito.when(orderService.create(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(createOrder);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderOtherService/orderOther").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testAddCreateNewOrder() throws Exception {
Order order = new Order();
Mockito.when(orderService.addNewOrder(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(order);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderOtherService/orderOther/admin").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryOrders() throws Exception {
QueryInfo qi = new QueryInfo();
Mockito.when(orderService.queryOrders(Mockito.any(QueryInfo.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(qi);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderOtherService/orderOther/query").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryOrdersForRefresh() throws Exception {
QueryInfo qi = new QueryInfo();
Mockito.when(orderService.queryOrdersForRefresh(Mockito.any(QueryInfo.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(qi);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderOtherService/orderOther/refresh").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCalculateSoldTicket() throws Exception {
Date travelDate = new Date();
Mockito.when(orderService.queryAlreadySoldOrders(Mockito.any(Date.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/orderOther/" + travelDate.toString() + "/train_number"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetOrderPrice() throws Exception {
Mockito.when(orderService.getOrderPrice(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/orderOther/price/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testPayOrder() throws Exception {
Mockito.when(orderService.payOrder(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/orderOther/orderPay/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetOrderById() throws Exception {
Mockito.when(orderService.getOrderById(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/orderOther/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testModifyOrder() throws Exception {
Mockito.when(orderService.modifyOrder(Mockito.anyString(), Mockito.anyInt(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/orderOther/status/order_id/1"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testSecurityInfoCheck() throws Exception {
Date checkDate = new Date();
Mockito.when(orderService.checkSecurityAboutOrder(Mockito.any(Date.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/orderOther/security/" + checkDate.toString() + "/account_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testSaveOrderInfo() throws Exception {
Order orderInfo = new Order();
Mockito.when(orderService.saveChanges(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(orderInfo);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/orderOtherService/orderOther").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdateOrder() throws Exception {
Order order = new Order();
Mockito.when(orderService.updateOrder(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(order);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/orderOtherService/orderOther/admin").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDeleteOrder() throws Exception {
Mockito.when(orderService.deleteOrder(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/orderOtherService/orderOther/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testFindAllOrder() throws Exception {
Mockito.when(orderService.getAllOrders(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderOtherService/orderOther"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 10,998 | 53.450495 | 177 |
java
|
train-ticket
|
train-ticket-master/ts-order-other-service/src/test/java/other/service/OrderOtherServiceImplTest.java
|
package other.service;
import edu.fudan.common.entity.OrderSecurity;;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.util.Response;
import other.entity.Order;
import other.entity.OrderAlterInfo;
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 other.entity.*;
import other.repository.OrderOtherRepository;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import static org.mockito.internal.verification.VerificationModeFactory.times;
@RunWith(JUnit4.class)
public class OrderOtherServiceImplTest {
@InjectMocks
private OrderOtherServiceImpl orderOtherServiceImpl;
@Mock
private OrderOtherRepository orderOtherRepository;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testGetSoldTickets1() {
Seat seatRequest = new Seat();
ArrayList<Order> list = new ArrayList<>();
list.add(new Order());
Mockito.when(orderOtherRepository.findByTravelDateAndTrainNumber(Mockito.any(String.class), Mockito.anyString())).thenReturn(list);
Response result = orderOtherServiceImpl.getSoldTickets(seatRequest, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetSoldTickets2() {
Seat seatRequest = new Seat();
Mockito.when(orderOtherRepository.findByTravelDateAndTrainNumber(Mockito.any(String.class), Mockito.anyString())).thenReturn(null);
Response result = orderOtherServiceImpl.getSoldTickets(seatRequest, headers);
Assert.assertEquals(new Response<>(0, "Seat is Null.", null), result);
}
@Test
public void testFindOrderById1() {
String id = UUID.randomUUID().toString();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.findOrderById(id, headers);
Assert.assertEquals(new Response<>(0, "No Content by this id", null), result);
}
@Test
public void testFindOrderById2() {
String id = UUID.randomUUID().toString();
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Response result = orderOtherServiceImpl.findOrderById(id, headers);
Assert.assertEquals(new Response<>(1, "Success", order), result);
}
@Test
public void testCreate1() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
accountOrders.add(order);
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Response result = orderOtherServiceImpl.create(order, headers);
Assert.assertEquals(new Response<>(0, "Order already exist", order), result);
}
@Test
public void testCreate2() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderOtherServiceImpl.create(order, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testInitOrder1() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
orderOtherServiceImpl.initOrder(order, headers);
Mockito.verify(orderOtherRepository, times(1)).save(Mockito.any(Order.class));
}
@Test
public void testInitOrder2() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
orderOtherServiceImpl.initOrder(order, headers);
Mockito.verify(orderOtherRepository, times(0)).save(Mockito.any(Order.class));
}
@Test
public void testAlterOrder1() {
OrderAlterInfo oai = new OrderAlterInfo();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.alterOrder(oai, headers);
Assert.assertEquals(new Response<>(0, "Old Order Does Not Exists", null), result);
}
@Test
public void testAlterOrder2() {
OrderAlterInfo oai = new OrderAlterInfo(UUID.randomUUID().toString(), UUID.randomUUID().toString(), "login_token", new Order());
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
//mock create()
ArrayList<Order> accountOrders = new ArrayList<>();
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Response result = orderOtherServiceImpl.alterOrder(oai, headers);
Assert.assertEquals("Alter Order Success", result.getMsg());
}
@Test
public void testQueryOrders() {
ArrayList<Order> list = new ArrayList<>();
Order order = new Order();
order.setStatus(1);
list.add(order);
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(list);
QueryInfo qi = new QueryInfo();
qi.setEnableStateQuery(true);
qi.setEnableBoughtDateQuery(false);
qi.setEnableTravelDateQuery(false);
qi.setState(1);
Response result = orderOtherServiceImpl.queryOrders(qi, UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(1, "Get order num", list), result);
}
@Test
public void testQueryOrdersForRefresh() {
ArrayList<Order> list = new ArrayList<>();
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(list);
//mock queryForStationId()
Response<List<String>> response = new Response<>();
ResponseEntity<Response<List<String>>> 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);
QueryInfo qi = new QueryInfo();
qi.setEnableStateQuery(false);
qi.setEnableBoughtDateQuery(false);
qi.setEnableTravelDateQuery(false);
Response result = orderOtherServiceImpl.queryOrdersForRefresh(qi, UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testQueryForStationId() {
List<String> ids = new ArrayList<>();
HttpEntity requestEntity = new HttpEntity<>(ids, headers);
Response<List<String>> response = new Response<>();
ResponseEntity<Response<List<String>>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-station-service:12345/api/v1/stationservice/stations/namelist",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<List<String>>>() {
})).thenReturn(re);
List<String> result = orderOtherServiceImpl.queryForStationId(ids, headers);
Assert.assertNull(result);
}
@Test
public void testSaveChanges1() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.saveChanges(order, headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testSaveChanges2() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderOtherServiceImpl.saveChanges(order, headers);
Assert.assertEquals(new Response<>(1, "Success", order), result);
}
@Test
public void testCancelOrder1() {
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.cancelOrder(UUID.randomUUID().toString(), UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testCancelOrder2() {
Order oldOrder = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(oldOrder);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderOtherServiceImpl.cancelOrder(UUID.randomUUID().toString(), UUID.randomUUID().toString(), headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testQueryAlreadySoldOrders() {
ArrayList<Order> orders = new ArrayList<>();
Mockito.when(orderOtherRepository.findByTravelDateAndTrainNumber(Mockito.any(String.class), Mockito.anyString())).thenReturn(orders);
Response result = orderOtherServiceImpl.queryAlreadySoldOrders(new Date(), "G1234", headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetAllOrders1() {
Mockito.when(orderOtherRepository.findAll()).thenReturn(null);
Response result = orderOtherServiceImpl.getAllOrders(headers);
Assert.assertEquals(new Response<>(0, "No Content", null), result);
}
@Test
public void testGetAllOrders2() {
ArrayList<Order> orders = new ArrayList<>();
Mockito.when(orderOtherRepository.findAll()).thenReturn(orders);
Response result = orderOtherServiceImpl.getAllOrders(headers);
Assert.assertEquals(new Response<>(1, "Success", orders), result);
}
@Test
public void testModifyOrder1() {
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.modifyOrder(UUID.randomUUID().toString().toString(), 1, headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testModifyOrder2() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderOtherServiceImpl.modifyOrder(UUID.randomUUID().toString().toString(), 1, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetOrderPrice1() {
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.getOrderPrice(UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", "-1.0"), result);
}
@Test
public void testGetOrderPrice2() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Response result = orderOtherServiceImpl.getOrderPrice(UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(1, "Success", order.getPrice()), result);
}
@Test
public void testPayOrder1() {
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.payOrder(UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testPayOrder2() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderOtherServiceImpl.payOrder(UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetOrderById1() {
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.getOrderById(UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testGetOrderById2() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Response result = orderOtherServiceImpl.getOrderById(UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(1, "Success", order), result);
}
@Test
public void testCheckSecurityAboutOrder() {
ArrayList<Order> orders = new ArrayList<>();
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(orders);
Response result = orderOtherServiceImpl.checkSecurityAboutOrder(new Date(), UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(1, "Success", new OrderSecurity(0, 0)), result);
}
@Test
public void testDeleteOrder1() {
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.deleteOrder(UUID.randomUUID().toString().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Exist.", null), result);
}
@Test
public void testDeleteOrder2() {
Order order = new Order();
String orderUuid = UUID.randomUUID().toString();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.doNothing().doThrow(new RuntimeException()).when(orderOtherRepository).deleteById(Mockito.any(String.class));
Response result = orderOtherServiceImpl.deleteOrder(orderUuid.toString(), headers);
Assert.assertEquals(new Response<>(1, "Success", orderUuid), result);
}
@Test
public void testAddNewOrder1() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
accountOrders.add(order);
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Response result = orderOtherServiceImpl.addNewOrder(order, headers);
Assert.assertEquals(new Response<>(0, "Order already exist", null), result);
}
@Test
public void testAddNewOrder2() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
Mockito.when(orderOtherRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderOtherServiceImpl.addNewOrder(order, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testUpdateOrder1() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderOtherServiceImpl.updateOrder(order, headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testUpdateOrder2() {
Order order = new Order();
Mockito.when(orderOtherRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderOtherRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderOtherServiceImpl.updateOrder(order, headers);
Assert.assertEquals("Success", result.getMsg());
}
}
| 17,008 | 44.116711 | 141 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/OrderApplication.java
|
package order;
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 OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,176 | 32.628571 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/config/SecurityConfig.java
|
package order.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 order = "/api/v1/orderservice/order";
/**
* 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, order).hasAnyRole(admin, "USER")
.antMatchers(HttpMethod.PUT, order).hasAnyRole(admin, "USER")
.antMatchers(HttpMethod.DELETE, order).hasAnyRole(admin, "USER")
.antMatchers(HttpMethod.POST, "/api/v1/orderservice/order/admin").hasAnyRole(admin)
.antMatchers(HttpMethod.PUT, "/api/v1/orderservice/order/admin").hasAnyRole(admin)
.antMatchers("/api/v1/orderservice/order/**").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,795 | 40.714286 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/controller/OrderController.java
|
package order.controller;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.util.StringUtils;
import order.entity.*;
import order.service.OrderService;
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.Date;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/orderservice")
public class OrderController {
@Autowired
private OrderService orderService;
private static final Logger LOGGER = LoggerFactory.getLogger(OrderController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ Order Service ] !";
}
/***************************For Normal Use***************************/
@PostMapping(value = "/order/tickets")
public HttpEntity getTicketListByDateAndTripId(@RequestBody Seat seatRequest, @RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[getSoldTickets][Get Sold Ticket][Travel Date: {}]", seatRequest.getTravelDate().toString());
return ok(orderService.getSoldTickets(seatRequest, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/order")
public HttpEntity createNewOrder(@RequestBody Order createOrder, @RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[createNewOrder][Create Order][from {} to {} at {}]", createOrder.getFrom(), createOrder.getTo(), createOrder.getTravelDate());
return ok(orderService.create(createOrder, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/order/admin")
public HttpEntity addcreateNewOrder(@RequestBody Order order, @RequestHeader HttpHeaders headers) {
return ok(orderService.addNewOrder(order, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/order/query")
public HttpEntity queryOrders(@RequestBody OrderInfo qi,
@RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[queryOrders][Query Orders][for LoginId :{}]", qi.getLoginId());
return ok(orderService.queryOrders(qi, qi.getLoginId(), headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/order/refresh")
public HttpEntity queryOrdersForRefresh(@RequestBody OrderInfo qi,
@RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[queryOrdersForRefresh][Query Orders][for LoginId:{}]", qi.getLoginId());
return ok(orderService.queryOrdersForRefresh(qi, qi.getLoginId(), headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/order/{travelDate}/{trainNumber}")
public HttpEntity calculateSoldTicket(@PathVariable String travelDate, @PathVariable String trainNumber,
@RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[queryAlreadySoldOrders][Calculate Sold Tickets][Date: {} TrainNumber: {}]", travelDate, trainNumber);
return ok(orderService.queryAlreadySoldOrders(StringUtils.String2Date(travelDate), trainNumber, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/order/price/{orderId}")
public HttpEntity getOrderPrice(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[getOrderPrice][Get Order Price][OrderId: {}]", orderId);
// String
return ok(orderService.getOrderPrice(orderId, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/order/orderPay/{orderId}")
public HttpEntity payOrder(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[payOrder][Pay Order][OrderId: {}]", orderId);
// Order
return ok(orderService.payOrder(orderId, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/order/{orderId}")
public HttpEntity getOrderById(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[getOrderById][Get Order By Id][OrderId: {}]", orderId);
// Order
return ok(orderService.getOrderById(orderId, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/order/status/{orderId}/{status}")
public HttpEntity modifyOrder(@PathVariable String orderId, @PathVariable int status, @RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[modifyOrder][Modify Order Status][OrderId: {}]", orderId);
// Order
return ok(orderService.modifyOrder(orderId, status, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/order/security/{checkDate}/{accountId}")
public HttpEntity securityInfoCheck(@PathVariable String checkDate, @PathVariable String accountId,
@RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[checkSecurityAboutOrder][Security Info Get][AccountId:{}]", accountId);
return ok(orderService.checkSecurityAboutOrder(StringUtils.String2Date(checkDate), accountId, headers));
}
@CrossOrigin(origins = "*")
@PutMapping(path = "/order")
public HttpEntity saveOrderInfo(@RequestBody Order orderInfo,
@RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[saveChanges][Save Order Info][OrderId:{}]",orderInfo.getId());
return ok(orderService.saveChanges(orderInfo, headers));
}
@CrossOrigin(origins = "*")
@PutMapping(path = "/order/admin")
public HttpEntity updateOrder(@RequestBody Order order, @RequestHeader HttpHeaders headers) {
// Order
OrderController.LOGGER.info("[updateOrder][Update Order][OrderId: {}]", order.getId());
return ok(orderService.updateOrder(order, headers));
}
@CrossOrigin(origins = "*")
@DeleteMapping(path = "/order/{orderId}")
public HttpEntity deleteOrder(@PathVariable String orderId, @RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[deleteOrder][Delete Order][OrderId: {}]", orderId);
// Order
return ok(orderService.deleteOrder(orderId, headers));
}
/***************For super admin(Single Service Test*******************/
@CrossOrigin(origins = "*")
@GetMapping(path = "/order")
public HttpEntity findAllOrder(@RequestHeader HttpHeaders headers) {
OrderController.LOGGER.info("[getAllOrders][Find All Order]");
// ArrayList<Order>
return ok(orderService.getAllOrders(headers));
}
}
| 6,812 | 41.58125 | 164 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/entity/Order.java
|
package order.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import edu.fudan.common.entity.OrderStatus;
import edu.fudan.common.entity.SeatClass;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import lombok.ToString;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.util.Date;
import edu.fudan.common.entity.SeatClass;
/**
* @author fdse
*/
@Data
@Table(name = "orders")
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
@ToString
@JsonIgnoreProperties(ignoreUnknown = true)
public class Order {
@Id
@Column(length = 36)
@GeneratedValue(generator = "jpa-uuid")
private String id;
private String boughtDate;
private String travelDate;
private String travelTime;
/**
* Which Account Bought it
*/
@Column(length = 36)
private String accountId;
/**
* Tickets bought for whom....
*/
private String contactsName;
private int documentType;
private String contactsDocumentNumber;
private String trainNumber;
private int coachNumber;
private int seatClass;
private String seatNumber;
@Column(name = "from_station")
private String from;
@Column(name = "to_station")
private String to;
private int status;
private String price;
public Order(){
boughtDate = StringUtils.Date2String(new Date(System.currentTimeMillis()));
travelDate = StringUtils.Date2String(new Date(123456789));
trainNumber = "G1235";
coachNumber = 5;
seatClass = SeatClass.FIRSTCLASS.getCode();
seatNumber = "1";
from = "shanghai";
to = "taiyuan";
status = OrderStatus.PAID.getCode();
price = "0.0";
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Order other = (Order) obj;
return getBoughtDate().equals(other.getBoughtDate())
&& getBoughtDate().equals(other.getTravelDate())
&& getTravelTime().equals(other.getTravelTime())
&& accountId .equals( other.getAccountId() )
&& contactsName.equals(other.getContactsName())
&& contactsDocumentNumber.equals(other.getContactsDocumentNumber())
&& documentType == other.getDocumentType()
&& trainNumber.equals(other.getTrainNumber())
&& coachNumber == other.getCoachNumber()
&& seatClass == other.getSeatClass()
&& seatNumber .equals(other.getSeatNumber())
&& from.equals(other.getFrom())
&& to.equals(other.getTo())
&& status == other.getStatus()
&& price.equals(other.price);
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + (id == null ? 0 : id.hashCode());
return result;
}
}
| 3,154 | 24.24 | 83 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/entity/OrderAlterInfo.java
|
package order.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@AllArgsConstructor
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class OrderAlterInfo {
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String accountId;
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String previousOrderId;
private String loginToken;
private Order newOrderInfo;
public OrderAlterInfo(){
newOrderInfo = new Order();
}
}
| 734 | 20 | 81 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/entity/OrderInfo.java
|
package order.entity;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import java.util.Date;
/**
* @author fdse
*/
@Data
public class OrderInfo {
/**
* account id
*/
private String loginId;
private String travelDateStart;
private String travelDateEnd;
private String boughtDateStart;
private String boughtDateEnd;
private int state;
private boolean enableTravelDateQuery;
private boolean enableBoughtDateQuery;
private boolean enableStateQuery;
public OrderInfo(){
//Default Constructor
}
public String getLoginId() {
return loginId;
}
public void setLoginId(String loginId) {
this.loginId = loginId;
}
public int getState() {
return state;
}
public void enableTravelDateQuery(String startTime, String endTime){
enableTravelDateQuery = true;
travelDateStart = startTime;
travelDateEnd = endTime;
}
public void disableTravelDateQuery(){
enableTravelDateQuery = false;
travelDateStart = null;
travelDateEnd = null;
}
public void enableBoughtDateQuery(String startTime, String endTime){
enableBoughtDateQuery = true;
boughtDateStart = startTime;
boughtDateEnd = endTime;
}
public void disableBoughtDateQuery(){
enableBoughtDateQuery = false;
boughtDateStart = null;
boughtDateEnd = null;
}
public void enableStateQuery(int targetStatus){
enableStateQuery = true;
state = targetStatus;
}
public void disableStateQuery(){
enableTravelDateQuery = false;
state = -1;
}
public boolean isEnableTravelDateQuery() {
return enableTravelDateQuery;
}
public boolean isEnableBoughtDateQuery() {
return enableBoughtDateQuery;
}
public boolean isEnableStateQuery() {
return enableStateQuery;
}
}
| 1,958 | 19.195876 | 72 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/init/InitData.java
|
package order.init;
import edu.fudan.common.util.StringUtils;
import order.entity.Order;
import order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.UUID;
/**
* @author fdse
*/
@Component
public class InitData implements CommandLineRunner {
@Autowired
OrderService service;
String accountId = "4d2a46c7-71cb-4cf1-b5bb-b68406d9da6f";
String contactName = "Contacts_One";
String contactDocumentNumber = "DocumentNumber_One";
String firstClass = "FirstClass-30";
String price = "100.0";
@Override
public void run(String... args)throws Exception{
Order order = new Order();
order.setId("5ad7750b-a68b-49c0-a8c0-32776b067703");
order.setTravelDate("2022-10-01 00:00:00"); //NOSONAR
order.setTravelTime("2022-10-01 00:00:00"); //NOSONAR
order.setAccountId(accountId);
order.setContactsName(contactName);
order.setDocumentType(1);
order.setContactsDocumentNumber(contactDocumentNumber);
order.setTrainNumber("G1237");
order.setCoachNumber(5);
order.setSeatClass(2);
order.setSeatNumber(firstClass);
order.setFrom("nanjing");
order.setTo("shanghaihongqiao");
order.setStatus(0);
order.setPrice(price);
service.initOrder(order, null);
Order orderTwo = new Order();
orderTwo.setId("8177ac5a-61ac-42f4-83f4-bd7b394d0531");
orderTwo.setTravelDate("2022-10-01 00:00:00"); //NOSONAR
orderTwo.setTravelTime("2022-10-01 00:00:00"); //NOSONAR
orderTwo.setAccountId(accountId);
orderTwo.setContactsName(contactName);
orderTwo.setDocumentType(1);
orderTwo.setContactsDocumentNumber(contactDocumentNumber);
orderTwo.setTrainNumber("G1234");
orderTwo.setCoachNumber(5);
orderTwo.setSeatClass(2);
orderTwo.setSeatNumber(firstClass);
orderTwo.setFrom("shanghai");
orderTwo.setTo("beijing");
orderTwo.setStatus(0);
orderTwo.setPrice(price);
service.initOrder(orderTwo, null);
Order orderThree = new Order();
orderThree.setId("d3c91694-d5b8-424c-9974-e14c89226e49");
orderThree.setTravelDate("2022-10-01 00:00:00"); //NOSONAR
orderThree.setTravelTime("2022-10-01 00:00:00"); //NOSONAR
orderThree.setAccountId(accountId);
orderThree.setContactsName(contactName);
orderThree.setDocumentType(1);
orderThree.setContactsDocumentNumber(contactDocumentNumber);
orderThree.setTrainNumber("G1235");
orderThree.setCoachNumber(5);
orderThree.setSeatClass(2);
orderThree.setSeatNumber(firstClass);
orderThree.setFrom("shanghai");
orderThree.setTo("beijing");
orderThree.setStatus(0);
orderThree.setPrice(price);
service.initOrder(orderThree, null);
}
}
| 3,053 | 34.511628 | 68 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/repository/OrderRepository.java
|
package order.repository;
import order.entity.Order;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.Date;
import java.util.Optional;
import java.util.UUID;
/**
* @author fdse
*/
@Repository
public interface OrderRepository extends JpaRepository<Order, String> {
@Override
Optional<Order> findById(String id);
@Override
ArrayList<Order> findAll();
ArrayList<Order> findByAccountId(String accountId);
ArrayList<Order> findByTravelDateAndTrainNumber(String travelDate,String trainNumber);
@Override
void deleteById(String id);
}
| 736 | 22.774194 | 90 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/service/OrderService.java
|
package order.service;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.util.Response;
import order.entity.*;
import org.springframework.http.HttpHeaders;
import java.util.Date;
import java.util.UUID;
/**
* @author fdse
*/
public interface OrderService {
Response findOrderById(String id, HttpHeaders headers);
Response create(Order newOrder, HttpHeaders headers);
Response saveChanges(Order order, HttpHeaders headers);
Response cancelOrder(String accountId, String orderId, HttpHeaders headers);
Response queryOrders(OrderInfo qi, String accountId, HttpHeaders headers);
Response queryOrdersForRefresh(OrderInfo qi, String accountId, HttpHeaders headers);
Response alterOrder(OrderAlterInfo oai, HttpHeaders headers);
Response queryAlreadySoldOrders(Date travelDate, String trainNumber, HttpHeaders headers);
Response getAllOrders(HttpHeaders headers);
Response modifyOrder(String orderId, int status, HttpHeaders headers);
Response getOrderPrice(String orderId, HttpHeaders headers);
Response payOrder(String orderId, HttpHeaders headers);
Response getOrderById(String orderId , HttpHeaders headers);
Response checkSecurityAboutOrder(Date checkDate, String accountId, HttpHeaders headers);
void initOrder(Order order, HttpHeaders headers);
Response deleteOrder(String orderId, HttpHeaders headers);
Response getSoldTickets(Seat seatRequest, HttpHeaders headers);
Response addNewOrder(Order order, HttpHeaders headers);
Response updateOrder(Order order, HttpHeaders headers);
}
| 1,592 | 28.5 | 94 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/main/java/order/service/OrderServiceImpl.java
|
package order.service;
import edu.fudan.common.entity.*;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import order.entity.OrderAlterInfo;
import order.entity.Order;
import order.entity.OrderInfo;
import order.repository.OrderRepository;
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 java.util.*;
/**
* @author fdse
*/
@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private OrderRepository orderRepository;
@Autowired
private RestTemplate restTemplate;
private static final Logger LOGGER = LoggerFactory.getLogger(OrderServiceImpl.class);
@Autowired
private DiscoveryClient discoveryClient;
private String getServiceUrl(String serviceName) {
return "http://" + serviceName; }
// @Value("${station-service.url}")
// String station_service_url;
String success = "Success";
String orderNotFound = "Order Not Found";
@Override
public Response getSoldTickets(Seat seatRequest, HttpHeaders headers) {
ArrayList<Order> list = orderRepository.findByTravelDateAndTrainNumber(seatRequest.getTravelDate(),
seatRequest.getTrainNumber());
if (list != null && !list.isEmpty()) {
Set ticketSet = new HashSet();
for (Order tempOrder : list) {
ticketSet.add(new Ticket(Integer.parseInt(tempOrder.getSeatNumber()),
tempOrder.getFrom(), tempOrder.getTo()));
}
LeftTicketInfo leftTicketInfo = new LeftTicketInfo();
leftTicketInfo.setSoldTickets(ticketSet);
OrderServiceImpl.LOGGER.info("[getSoldTickets][Left ticket info][info is: {}]", leftTicketInfo.toString());
return new Response<>(1, success, leftTicketInfo);
} else {
OrderServiceImpl.LOGGER.warn("[getSoldTickets][Seat][Left ticket info is empty][seat from date: {}, train number: {}]",seatRequest.getTravelDate(),seatRequest.getTrainNumber()); //warn级别，获取资源但资源为空
return new Response<>(0, "Order is Null.", null);
}
}
@Override
public Response findOrderById(String id, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(id);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.warn("[findOrderById][Find Order By Id Fail][No content][id: {}] ",id); //获取资源但资源为空
return new Response<>(0, "No Content by this id", null);
} else {
Order order = op.get();
OrderServiceImpl.LOGGER.warn("[findOrderById][Find Order By Id Success][id: {}] ",id); //获取资源但资源为空
return new Response<>(1, success, order);
}
}
@Override
public Response create(Order order, HttpHeaders headers) {
OrderServiceImpl.LOGGER.info("[create][Create Order][Ready to Create Order]");
ArrayList<Order> accountOrders = orderRepository.findByAccountId(order.getAccountId());
if (accountOrders.contains(order)) {
OrderServiceImpl.LOGGER.error("[create][Order Create Fail][Order already exists][OrderId: {}]", order.getId());
return new Response<>(0, "Order already exist", null);
} else {
order.setId(UUID.randomUUID().toString());
order=orderRepository.save(order);
OrderServiceImpl.LOGGER.info("[create][Order Create Success][Order Price][OrderId:{} , Price: {}]",order.getId(),order.getPrice());
return new Response<>(1, success, order);
}
}
@Override
public Response alterOrder(OrderAlterInfo oai, HttpHeaders headers) {
String oldOrderId = oai.getPreviousOrderId();
Optional<Order> op = orderRepository.findById(oldOrderId);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[alterOrder][Alter Order Fail][Order do not exist][OrderId: {}]", oldOrderId);
return new Response<>(0, "Old Order Does Not Exists", null);
}
Order oldOrder = op.get();
oldOrder.setStatus(OrderStatus.CANCEL.getCode());
saveChanges(oldOrder, headers);
Order newOrder = oai.getNewOrderInfo();
newOrder.setId(UUID.randomUUID().toString());
Response cor = create(oai.getNewOrderInfo(), headers);
if (cor.getStatus() == 1) {
OrderServiceImpl.LOGGER.info("[alterOrder][Alter Order Success][newOrderId: {}]",newOrder.getId());
return new Response<>(1, success, newOrder);
} else {
OrderServiceImpl.LOGGER.error("[alterOrder][Alter Order Fail][Create new order fail][newOrderId: {}]", newOrder.getId());
return new Response<>(0, cor.getMsg(), null);
}
}
@Override
public Response<ArrayList<Order>> queryOrders(OrderInfo qi, String accountId, HttpHeaders headers) {
//1.Get all orders of the user
ArrayList<Order> list = orderRepository.findByAccountId(accountId);
OrderServiceImpl.LOGGER.info("[queryOrders][Step 1][Get Orders Number of Account][size: {}]", list.size());
//2.Check is these orders fit the requirement/
if (qi.isEnableStateQuery() || qi.isEnableBoughtDateQuery() || qi.isEnableTravelDateQuery()) {
ArrayList<Order> finalList = new ArrayList<>();
for (Order tempOrder : list) {
boolean statePassFlag = false;
boolean boughtDatePassFlag = false;
boolean travelDatePassFlag = false;
//3.Check order state requirement.
if (qi.isEnableStateQuery()) {
if (tempOrder.getStatus() != qi.getState()) {
statePassFlag = false;
} else {
statePassFlag = true;
}
} else {
statePassFlag = true;
}
OrderServiceImpl.LOGGER.info("[queryOrders][Step 2][Check Status Fits End]");
//4.Check order travel date requirement.
Date boughtDate = StringUtils.String2Date(tempOrder.getBoughtDate());
Date travelDate = StringUtils.String2Date(tempOrder.getTravelDate());
Date travelDateEnd = StringUtils.String2Date(qi.getTravelDateEnd());
Date boughtDateStart = StringUtils.String2Date(qi.getBoughtDateStart());
Date boughtDateEnd = StringUtils.String2Date(qi.getBoughtDateEnd());
if (qi.isEnableTravelDateQuery()) {
if (travelDate.before(travelDateEnd) &&
travelDate.after(boughtDateStart)) {
travelDatePassFlag = true;
} else {
travelDatePassFlag = false;
}
} else {
travelDatePassFlag = true;
}
OrderServiceImpl.LOGGER.info("[queryOrders][Step 2][Check Travel Date End]");
//5.Check order bought date requirement.
if (qi.isEnableBoughtDateQuery()) {
if (boughtDate.before(boughtDateEnd) &&
boughtDate.after(boughtDateStart)) {
boughtDatePassFlag = true;
} else {
boughtDatePassFlag = false;
}
} else {
boughtDatePassFlag = true;
}
OrderServiceImpl.LOGGER.info("[queryOrders][Step 2][Check Bought Date End]");
//6.check if all requirement fits.
if (statePassFlag && boughtDatePassFlag && travelDatePassFlag) {
finalList.add(tempOrder);
}
OrderServiceImpl.LOGGER.info("[queryOrders][Step 2][Check All Requirement End]");
}
OrderServiceImpl.LOGGER.info("[queryOrders][Get order num][size:{}]", finalList.size());
return new Response<>(1, "Get order num", finalList);
} else {
OrderServiceImpl.LOGGER.warn("[queryOrders][Orders don't fit the requirement][loginId: {}]", qi.getLoginId());
return new Response<>(1, "Get order num", list);
}
}
@Override
public Response queryOrdersForRefresh(OrderInfo qi, String accountId, HttpHeaders headers) {
ArrayList<Order> orders = queryOrders(qi, accountId, headers).getData();
ArrayList<String> stationIds = new ArrayList<>();
for (Order order : orders) {
stationIds.add(order.getFrom());
stationIds.add(order.getTo());
}
// List<String> names = queryForStationId(stationIds, headers);
for (int i = 0; i < orders.size(); i++) {
orders.get(i).setFrom(stationIds.get(i * 2));
orders.get(i).setTo(stationIds.get(i * 2 + 1));
}
return new Response<>(1, "Query Orders For Refresh Success", orders);
}
public List<String> queryForStationId(List<String> ids, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(ids, null);
String station_service_url=getServiceUrl("ts-station-service");
ResponseEntity<Response<List<String>>> re = restTemplate.exchange(
station_service_url + "/api/v1/stationservice/stations/namelist",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<List<String>>>() {
});
OrderServiceImpl.LOGGER.info("[queryForStationId][Station Name List][Name List is: {}]", re.getBody().toString());
return re.getBody().getData();
}
@Override
public Response saveChanges(Order order, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(order.getId());
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[saveChanges][Modify Order Fail][Order not found][OrderId: {}]", order.getId());
return new Response<>(0, orderNotFound, null);
} else {
Order oldOrder = op.get();
oldOrder.setAccountId(order.getAccountId());
oldOrder.setBoughtDate(order.getBoughtDate());
oldOrder.setTravelDate(order.getTravelDate());
oldOrder.setTravelTime(order.getTravelTime());
oldOrder.setCoachNumber(order.getCoachNumber());
oldOrder.setSeatClass(order.getSeatClass());
oldOrder.setSeatNumber(order.getSeatNumber());
oldOrder.setFrom(order.getFrom());
oldOrder.setTo(order.getTo());
oldOrder.setStatus(order.getStatus());
oldOrder.setTrainNumber(order.getTrainNumber());
oldOrder.setPrice(order.getPrice());
oldOrder.setContactsName(order.getContactsName());
oldOrder.setContactsDocumentNumber(order.getContactsDocumentNumber());
oldOrder.setDocumentType(order.getDocumentType());
orderRepository.save(oldOrder);
OrderServiceImpl.LOGGER.info("[saveChanges][Modify Order Success][OrderId: {}]", order.getId());
return new Response<>(1, success, oldOrder);
}
}
@Override
public Response cancelOrder(String accountId, String orderId, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(orderId);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[cancelOrder][Cancel Order Fail][Order not found][OrderId: {}]", orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order oldOrder = op.get();
oldOrder.setStatus(OrderStatus.CANCEL.getCode());
orderRepository.save(oldOrder);
OrderServiceImpl.LOGGER.info("[cancelOrder][Cancel Order Success][OrderId: {}]", orderId);
return new Response<>(1, success, oldOrder);
}
}
@Override
public Response queryAlreadySoldOrders(Date travelDate, String trainNumber, HttpHeaders headers) {
ArrayList<Order> orders = orderRepository.findByTravelDateAndTrainNumber(StringUtils.Date2String(travelDate), trainNumber);
SoldTicket cstr = new SoldTicket();
cstr.setTravelDate(travelDate);
cstr.setTrainNumber(trainNumber);
OrderServiceImpl.LOGGER.info("[queryAlreadySoldOrders][Calculate Sold Ticket][Get Orders Number: {}]", orders.size());
for (Order order : orders) {
if (order.getStatus() >= OrderStatus.CHANGE.getCode()) {
continue;
}
if (order.getSeatClass() == SeatClass.NONE.getCode()) {
cstr.setNoSeat(cstr.getNoSeat() + 1);
} else if (order.getSeatClass() == SeatClass.BUSINESS.getCode()) {
cstr.setBusinessSeat(cstr.getBusinessSeat() + 1);
} else if (order.getSeatClass() == SeatClass.FIRSTCLASS.getCode()) {
cstr.setFirstClassSeat(cstr.getFirstClassSeat() + 1);
} else if (order.getSeatClass() == SeatClass.SECONDCLASS.getCode()) {
cstr.setSecondClassSeat(cstr.getSecondClassSeat() + 1);
} else if (order.getSeatClass() == SeatClass.HARDSEAT.getCode()) {
cstr.setHardSeat(cstr.getHardSeat() + 1);
} else if (order.getSeatClass() == SeatClass.SOFTSEAT.getCode()) {
cstr.setSoftSeat(cstr.getSoftSeat() + 1);
} else if (order.getSeatClass() == SeatClass.HARDBED.getCode()) {
cstr.setHardBed(cstr.getHardBed() + 1);
} else if (order.getSeatClass() == SeatClass.SOFTBED.getCode()) {
cstr.setSoftBed(cstr.getSoftBed() + 1);
} else if (order.getSeatClass() == SeatClass.HIGHSOFTBED.getCode()) {
cstr.setHighSoftBed(cstr.getHighSoftBed() + 1);
} else {
OrderServiceImpl.LOGGER.info("[queryAlreadySoldOrders][Calculate Sold Tickets][Seat class not exists][Order ID: {}]", order.getId());
}
}
return new Response<>(1, success, cstr);
}
@Override
public Response getAllOrders(HttpHeaders headers) {
ArrayList<Order> orders = orderRepository.findAll();
if (orders != null && !orders.isEmpty()) {
OrderServiceImpl.LOGGER.warn("[getAllOrders][Find all orders Success][size:{}]",orders.size());
return new Response<>(1, "Success.", orders);
} else {
OrderServiceImpl.LOGGER.warn("[getAllOrders][Find all orders Fail][{}]","No content");
return new Response<>(0, "No Content.", null);
}
}
@Override
public Response modifyOrder(String orderId, int status, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(orderId);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[modifyOrder][Modify order Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order order = op.get();
order.setStatus(status);
orderRepository.save(order);
OrderServiceImpl.LOGGER.info("[modifyOrder][Modify order Success][OrderId: {}]",orderId);
return new Response<>(1, "Modify Order Success", order);
}
}
@Override
public Response getOrderPrice(String orderId, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(orderId);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[getOrderPrice][Get order price Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, "-1.0");
} else {
Order order = op.get();
OrderServiceImpl.LOGGER.info("[getOrderPrice][Get Order Price Success][OrderId: {} , Price: {}]",orderId ,order.getPrice());
return new Response<>(1, success, order.getPrice());
}
}
@Override
public Response payOrder(String orderId, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(orderId);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[payOrder][Pay order Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order order = op.get();
order.setStatus(OrderStatus.PAID.getCode());
orderRepository.save(order);
OrderServiceImpl.LOGGER.info("[payOrder][Pay order Success][OrderId: {}]",orderId);
return new Response<>(1, "Pay Order Success.", order);
}
}
@Override
public Response getOrderById(String orderId, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(orderId);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.warn("[getOrderById][Get Order By ID Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, orderNotFound, null);
} else {
Order order = op.get();
OrderServiceImpl.LOGGER.info("[getOrderById][Get Order By ID Success][OrderId: {}]",orderId);
return new Response<>(1, "Success.", order);
}
}
@Override
public void initOrder(Order order, HttpHeaders headers) {
Optional<Order> op = orderRepository.findById(order.getId());
if (!op.isPresent()) {
orderRepository.save(order);
OrderServiceImpl.LOGGER.info("[initOrder][Init Order Success][OrderId: {}]", order.getId());
} else {
Order orderTemp = op.get();
OrderServiceImpl.LOGGER.error("[initOrder][Init Order Fail][Order Already Exists][OrderId: {}]", order.getId());
}
}
@Override
public Response checkSecurityAboutOrder(Date dateFrom, String accountId, HttpHeaders headers) {
OrderSecurity result = new OrderSecurity();
ArrayList<Order> orders = orderRepository.findByAccountId(accountId);
int countOrderInOneHour = 0;
int countTotalValidOrder = 0;
Calendar ca = Calendar.getInstance();
ca.setTime(dateFrom);
ca.add(Calendar.HOUR_OF_DAY, -1);
dateFrom = ca.getTime();
for (Order order : orders) {
if (order.getStatus() == OrderStatus.NOTPAID.getCode() ||
order.getStatus() == OrderStatus.PAID.getCode() ||
order.getStatus() == OrderStatus.COLLECTED.getCode()) {
countTotalValidOrder += 1;
}
Date boughtDate = StringUtils.String2Date(order.getBoughtDate());
if (boughtDate.after(dateFrom)) {
countOrderInOneHour += 1;
}
}
result.setOrderNumInLastOneHour(countOrderInOneHour);
result.setOrderNumOfValidOrder(countTotalValidOrder);
return new Response<>(1, "Check Security Success . ", result);
}
@Override
public Response deleteOrder(String orderId, HttpHeaders headers) {
String orderUuid = UUID.fromString(orderId).toString();
Optional<Order> op = orderRepository.findById(orderUuid);
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[deleteOrder][Delete order Fail][Order not found][OrderId: {}]",orderId);
return new Response<>(0, "Order Not Exist.", null);
} else {
Order order = op.get();
orderRepository.deleteById(orderUuid);
OrderServiceImpl.LOGGER.info("[deleteOrder][Delete order Success][OrderId: {}]",orderId);
return new Response<>(1, "Delete Order Success", order);
}
}
@Override
public Response addNewOrder(Order order, HttpHeaders headers) {
OrderServiceImpl.LOGGER.info("[addNewOrder][Admin Add Order][Ready to Add Order]");
ArrayList<Order> accountOrders = orderRepository.findByAccountId(order.getAccountId());
if (accountOrders.contains(order)) {
OrderServiceImpl.LOGGER.error("[addNewOrder][Admin Add Order Fail][Order already exists][OrderId: {}]",order.getId());
return new Response<>(0, "Order already exist", null);
} else {
order.setId(UUID.randomUUID().toString());
orderRepository.save(order);
OrderServiceImpl.LOGGER.info("[addNewOrder][Admin Add Order Success][OrderId: {} , Price: {}]",order.getId() ,order.getPrice());
return new Response<>(1, "Add new Order Success", order);
}
}
@Override
public Response updateOrder(Order order, HttpHeaders headers) {
LOGGER.info("[updateOrder][Admin Update Order][Order Info:{}] ", order.toString());
Optional<Order> op = orderRepository.findById(order.getId());
if (!op.isPresent()) {
OrderServiceImpl.LOGGER.error("[updateOrder][Admin Update Order Fail][Order not found][OrderId: {}]",order.getId());
return new Response<>(0, "Order Not Found, Can't update", null);
} else {
Order oldOrder = op.get();
//OrderServiceImpl.LOGGER.info("{}", oldOrder.toString());
oldOrder.setAccountId(order.getAccountId());
oldOrder.setBoughtDate(order.getBoughtDate());
oldOrder.setTravelDate(order.getTravelDate());
oldOrder.setTravelTime(order.getTravelTime());
oldOrder.setCoachNumber(order.getCoachNumber());
oldOrder.setSeatClass(order.getSeatClass());
oldOrder.setSeatNumber(order.getSeatNumber());
oldOrder.setFrom(order.getFrom());
oldOrder.setTo(order.getTo());
oldOrder.setStatus(order.getStatus());
oldOrder.setTrainNumber(order.getTrainNumber());
oldOrder.setPrice(order.getPrice());
oldOrder.setContactsName(order.getContactsName());
oldOrder.setContactsDocumentNumber(order.getContactsDocumentNumber());
oldOrder.setDocumentType(order.getDocumentType());
orderRepository.save(oldOrder);
OrderServiceImpl.LOGGER.info("[updateOrder][Admin Update Order Success][OrderId: {}]",order.getId());
return new Response<>(1, "Admin Update Order Success", oldOrder);
}
}
}
| 22,778 | 47.363057 | 208 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/test/java/order/controller/OrderControllerTest.java
|
package order.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.util.Response;
import order.entity.Order;
import order.entity.OrderInfo;
import order.service.OrderService;
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.Date;
@RunWith(JUnit4.class)
public class OrderControllerTest {
@InjectMocks
private OrderController orderController;
@Mock
private OrderService orderService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(orderController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Order Service ] !"));
}
@Test
public void testGetTicketListByDateAndTripId() throws Exception {
Seat seatRequest = new Seat();
Mockito.when(orderService.getSoldTickets(Mockito.any(Seat.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(seatRequest);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderservice/order/tickets").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreateNewOrder() throws Exception {
Order createOrder = new Order();
Mockito.when(orderService.create(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(createOrder);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderservice/order").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testAddCreateNewOrder() throws Exception {
Order order = new Order();
Mockito.when(orderService.addNewOrder(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(order);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderservice/order/admin").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryOrders() throws Exception {
OrderInfo qi = new OrderInfo();
Mockito.when(orderService.queryOrders(Mockito.any(OrderInfo.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(qi);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderservice/order/query").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryOrdersForRefresh() throws Exception {
OrderInfo qi = new OrderInfo();
Mockito.when(orderService.queryOrdersForRefresh(Mockito.any(OrderInfo.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(qi);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/orderservice/order/refresh").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCalculateSoldTicket() throws Exception {
Date travelDate = new Date();
Mockito.when(orderService.queryAlreadySoldOrders(Mockito.any(Date.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/order/" + travelDate.toString() + "/train_number"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetOrderPrice() throws Exception {
Mockito.when(orderService.getOrderPrice(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/order/price/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testPayOrder() throws Exception {
Mockito.when(orderService.payOrder(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/order/orderPay/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetOrderById() throws Exception {
Mockito.when(orderService.getOrderById(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/order/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testModifyOrder() throws Exception {
Mockito.when(orderService.modifyOrder(Mockito.anyString(), Mockito.anyInt(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/order/status/order_id/1"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testSecurityInfoCheck() throws Exception {
Date checkDate = new Date();
Mockito.when(orderService.checkSecurityAboutOrder(Mockito.any(Date.class), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/order/security/" + checkDate.toString() + "/account_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testSaveOrderInfo() throws Exception {
Order orderInfo = new Order();
Mockito.when(orderService.saveChanges(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(orderInfo);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/orderservice/order").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdateOrder() throws Exception {
Order order = new Order();
Mockito.when(orderService.updateOrder(Mockito.any(Order.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(order);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/orderservice/order/admin").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDeleteOrder() throws Exception {
Mockito.when(orderService.deleteOrder(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/orderservice/order/order_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testFindAllOrder() throws Exception {
Mockito.when(orderService.getAllOrders(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/orderservice/order"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 10,807 | 52.50495 | 167 |
java
|
train-ticket
|
train-ticket-master/ts-order-service/src/test/java/order/service/OrderServiceImplTest.java
|
package order.service;
import edu.fudan.common.entity.OrderSecurity;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.util.Response;
import order.entity.*;
import order.repository.OrderRepository;
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 java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import static org.mockito.internal.verification.VerificationModeFactory.times;
@RunWith(JUnit4.class)
public class OrderServiceImplTest {
@InjectMocks
private OrderServiceImpl orderServiceImpl;
@Mock
private OrderRepository orderRepository;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testGetSoldTickets1() {
Seat seatRequest = new Seat();
ArrayList<Order> list = new ArrayList<>();
list.add(new Order());
Mockito.when(orderRepository.findByTravelDateAndTrainNumber(Mockito.any(String.class), Mockito.anyString())).thenReturn(list);
Response result = orderServiceImpl.getSoldTickets(seatRequest, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetSoldTickets2() {
Seat seatRequest = new Seat();
Mockito.when(orderRepository.findByTravelDateAndTrainNumber(Mockito.any(String.class), Mockito.anyString())).thenReturn(null);
Response result = orderServiceImpl.getSoldTickets(seatRequest, headers);
Assert.assertEquals(new Response<>(0, "Order is Null.", null), result);
}
@Test
public void testFindOrderById1() {
String id = UUID.randomUUID().toString();
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.findOrderById(id, headers);
Assert.assertEquals(new Response<>(0, "No Content by this id", null), result);
}
@Test
public void testFindOrderById2() {
String id = UUID.randomUUID().toString();
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Response result = orderServiceImpl.findOrderById(id, headers);
Assert.assertEquals(new Response<>(1, "Success", order), result);
}
@Test
public void testCreate1() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
accountOrders.add(order);
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Response result = orderServiceImpl.create(order, headers);
Assert.assertEquals(new Response<>(0, "Order already exist", null), result);
}
@Test
public void testCreate2() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderServiceImpl.create(order, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testInitOrder1() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
orderServiceImpl.initOrder(order, headers);
Mockito.verify(orderRepository, times(1)).save(Mockito.any(Order.class));
}
@Test
public void testInitOrder2() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
orderServiceImpl.initOrder(order, headers);
Mockito.verify(orderRepository, times(0)).save(Mockito.any(Order.class));
}
@Test
public void testAlterOrder1() {
OrderAlterInfo oai = new OrderAlterInfo();
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.alterOrder(oai, headers);
Assert.assertEquals(new Response<>(0, "Old Order Does Not Exists", null), result);
}
@Test
public void testAlterOrder2() {
OrderAlterInfo oai = new OrderAlterInfo(UUID.randomUUID().toString(), UUID.randomUUID().toString(), "login_token", new Order());
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
//mock create()
ArrayList<Order> accountOrders = new ArrayList<>();
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Response result = orderServiceImpl.alterOrder(oai, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testQueryOrders() {
ArrayList<Order> list = new ArrayList<>();
Order order = new Order();
order.setStatus(1);
list.add(order);
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(list);
OrderInfo qi = new OrderInfo();
qi.setEnableStateQuery(true);
qi.setEnableBoughtDateQuery(false);
qi.setEnableTravelDateQuery(false);
qi.setState(1);
Response result = orderServiceImpl.queryOrders(qi, UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(1, "Get order num", list), result);
}
@Test
public void testQueryOrdersForRefresh() {
ArrayList<Order> list = new ArrayList<>();
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(list);
//mock queryForStationId()
Response<List<String>> response = new Response<>();
ResponseEntity<Response<List<String>>> 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);
OrderInfo qi = new OrderInfo();
qi.setEnableStateQuery(false);
qi.setEnableBoughtDateQuery(false);
qi.setEnableTravelDateQuery(false);
Response result = orderServiceImpl.queryOrdersForRefresh(qi, UUID.randomUUID().toString(), headers);
Assert.assertEquals("Query Orders For Refresh Success", result.getMsg());
}
@Test
public void testQueryForStationId() {
List<String> ids = new ArrayList<>();
HttpEntity requestEntity = new HttpEntity<>(ids, headers);
Response<List<String>> response = new Response<>();
ResponseEntity<Response<List<String>>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-station-service:12345/api/v1/stationservice/stations/namelist",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<List<String>>>() {
})).thenReturn(re);
List<String> result = orderServiceImpl.queryForStationId(ids, headers);
Assert.assertNull(result);
}
@Test
public void testSaveChanges1() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.saveChanges(order, headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testSaveChanges2() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderServiceImpl.saveChanges(order, headers);
Assert.assertEquals(new Response<>(1, "Success", order), result);
}
@Test
public void testCancelOrder1() {
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.cancelOrder(UUID.randomUUID().toString(), UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testCancelOrder2() {
Order oldOrder = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(oldOrder);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderServiceImpl.cancelOrder(UUID.randomUUID().toString(), UUID.randomUUID().toString(), headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testQueryAlreadySoldOrders() {
ArrayList<Order> orders = new ArrayList<>();
Mockito.when(orderRepository.findByTravelDateAndTrainNumber(Mockito.any(String.class), Mockito.anyString())).thenReturn(orders);
Response result = orderServiceImpl.queryAlreadySoldOrders(new Date(), "G1234", headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetAllOrders1() {
Mockito.when(orderRepository.findAll()).thenReturn(null);
Response result = orderServiceImpl.getAllOrders(headers);
Assert.assertEquals(new Response<>(0, "No Content.", null), result);
}
@Test
public void testGetAllOrders2() {
ArrayList<Order> orders = new ArrayList<>();
orders.add(new Order());
Mockito.when(orderRepository.findAll()).thenReturn(orders);
Response result = orderServiceImpl.getAllOrders(headers);
Assert.assertEquals(new Response<>(1, "Success.", orders), result);
}
@Test
public void testModifyOrder1() {
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.modifyOrder(UUID.randomUUID().toString(), 1, headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testModifyOrder2() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderServiceImpl.modifyOrder(UUID.randomUUID().toString(), 1, headers);
Assert.assertEquals("Modify Order Success", result.getMsg());
}
@Test
public void testGetOrderPrice1() {
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.getOrderPrice(UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", "-1.0"), result);
}
@Test
public void testGetOrderPrice2() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Response result = orderServiceImpl.getOrderPrice(UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(1, "Success", order.getPrice()), result);
}
@Test
public void testPayOrder1() {
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.payOrder(UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testPayOrder2() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderServiceImpl.payOrder(UUID.randomUUID().toString(), headers);
Assert.assertEquals("Pay Order Success.", result.getMsg());
}
@Test
public void testGetOrderById1() {
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.getOrderById(UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Found", null), result);
}
@Test
public void testGetOrderById2() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Response result = orderServiceImpl.getOrderById(UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(1, "Success.", order), result);
}
@Test
public void testCheckSecurityAboutOrder() {
ArrayList<Order> orders = new ArrayList<>();
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(orders);
Response result = orderServiceImpl.checkSecurityAboutOrder(new Date(), UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(1, "Check Security Success . ", new OrderSecurity(0, 0)), result);
}
@Test
public void testDeleteOrder1() {
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.deleteOrder(UUID.randomUUID().toString(), headers);
Assert.assertEquals(new Response<>(0, "Order Not Exist.", null), result);
}
@Test
public void testDeleteOrder2() {
Order order = new Order();
String orderUuid = UUID.randomUUID().toString();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.doNothing().doThrow(new RuntimeException()).when(orderRepository).deleteById(Mockito.any(String.class));
Response result = orderServiceImpl.deleteOrder(orderUuid.toString(), headers);
Assert.assertEquals(new Response<>(1, "Delete Order Success", order), result);
}
@Test
public void testAddNewOrder1() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
accountOrders.add(order);
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Response result = orderServiceImpl.addNewOrder(order, headers);
Assert.assertEquals(new Response<>(0, "Order already exist", null), result);
}
@Test
public void testAddNewOrder2() {
Order order = new Order();
ArrayList<Order> accountOrders = new ArrayList<>();
Mockito.when(orderRepository.findByAccountId(Mockito.any(String.class))).thenReturn(accountOrders);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderServiceImpl.addNewOrder(order, headers);
Assert.assertEquals("Add new Order Success", result.getMsg());
}
@Test
public void testUpdateOrder1() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class))).thenReturn(null);
Response result = orderServiceImpl.updateOrder(order, headers);
Assert.assertEquals(new Response<>(0, "Order Not Found, Can't update", null), result);
}
@Test
public void testUpdateOrder2() {
Order order = new Order();
Mockito.when(orderRepository.findById(Mockito.any(String.class)).get()).thenReturn(order);
Mockito.when(orderRepository.save(Mockito.any(Order.class))).thenReturn(null);
Response result = orderServiceImpl.updateOrder(order, headers);
Assert.assertEquals("Admin Update Order Success", result.getMsg());
}
}
| 16,507 | 42.787798 | 136 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/PaymentApplication.java
|
package com.trainticket;
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 PaymentApplication {
public static void main(String[] args) {
SpringApplication.run(PaymentApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,161 | 31.277778 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/config/SecurityConfig.java
|
package com.trainticket.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/paymentservice/**").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,258 | 38.743902 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/controller/PaymentController.java
|
package com.trainticket.controller;
import com.trainticket.entity.Payment;
import com.trainticket.service.PaymentService;
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 static org.springframework.http.ResponseEntity.ok;
/**
* @author Chenjie
* @date 2017/4/7
*/
@RestController
@RequestMapping("/api/v1/paymentservice")
public class PaymentController {
@Autowired
PaymentService service;
private static final Logger LOGGER = LoggerFactory.getLogger(PaymentController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ Payment Service ] !";
}
@PostMapping(path = "/payment")
public HttpEntity pay(@RequestBody Payment info, @RequestHeader HttpHeaders headers) {
PaymentController.LOGGER.info("[pay][Pay][PaymentId: {}]", info.getId());
return ok(service.pay(info, headers));
}
@PostMapping(path = "/payment/money")
public HttpEntity addMoney(@RequestBody Payment info, @RequestHeader HttpHeaders headers) {
PaymentController.LOGGER.info("[addMoney][Add money][PaymentId: {}]", info.getId());
return ok(service.addMoney(info, headers));
}
@GetMapping(path = "/payment")
public HttpEntity query(@RequestHeader HttpHeaders headers) {
PaymentController.LOGGER.info("[query][Query payment]");
return ok(service.query(headers));
}
}
| 1,605 | 31.12 | 95 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/entity/Money.java
|
package com.trainticket.entity;
import lombok.AllArgsConstructor;
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
@AllArgsConstructor
@NoArgsConstructor
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
@Entity
public class Money {
@Id
@Column(length = 36)
@GeneratedValue(generator = "jpa-uuid")
private String id;
@Column(length = 36)
private String userId;
private String money; //NOSONAR
}
| 704 | 20.363636 | 81 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/entity/Payment.java
|
package com.trainticket.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.UUID;
/**
* @author fdse
*/
@Data
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class Payment {
@Id
@NotNull
@Column(length = 36)
@GeneratedValue(generator = "jpa-uuid")
private String id;
@NotNull
@Valid
@Column(length = 36)
private String orderId;
@NotNull
@Valid
@Column(length = 36)
private String userId;
@NotNull
@Valid
@Column(name = "payment_price")
private String price;
public Payment(){
this.id = UUID.randomUUID().toString();
this.orderId = "";
this.userId = "";
this.price = "";
}
}
| 997 | 18.96 | 81 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/init/InitData.java
|
package com.trainticket.init;
import com.trainticket.entity.Payment;
import com.trainticket.repository.PaymentRepository;
import com.trainticket.service.PaymentService;
import edu.fudan.common.util.Response;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author fdse
*/
@Component
public class InitData implements CommandLineRunner {
@Autowired
PaymentService service;
@Autowired
PaymentRepository paymentRepository;
@Override
public void run(String... args) throws Exception{
Payment payment = new Payment();
payment.setId("5ad7750ba68b49c0a8c035276b067701");
payment.setOrderId("5ad7750b-a68b-49c0-a8c0-32776b067701");
payment.setPrice("10000.0");
payment.setUserId("4d2a46c7-71cb-4cf1-b5bb-b68406d9da6f");
service.initPayment(payment, null);
/*Payment payment_1 = new Payment();
payment_1.setId("5ad7750ba68b49c0a8c035276b060000");
payment_1.setOrderId("5ad7750b-a68b-49c0-a8c0-32776b060000");
payment_1.setPrice("10000.0");
payment_1.setUserId("4d2a46c7-71cb-4cf1-b5bb-b68406d90000");
service.initPayment(payment_1, null); //findById
Payment payment_2 = new Payment();
payment_2.setId("5ad7750ba68b49c0a8c035276b061111");
payment_2.setOrderId("5ad7750b-a68b-49c0-a8c0-32776b061111");
payment_2.setPrice("5000.0");
payment_2.setUserId("4d2a46c7-71cb-4cf1-b5bb-b68406d91111");
service.initPayment(payment_2, null);
Response r1 = service.query(null); //findAll
List<Payment> payments = (List<Payment>) r1.getData();
System.out.println(payments.size());
Payment payment_3 = new Payment();
payment_3.setId("5ad7750ba68b49c0a8c035276b062222");
payment_3.setOrderId("5ad7750b-a68b-49c0-a8c0-32776b062222");
payment_3.setPrice("500.0");
payment_3.setUserId("4d2a46c7-71cb-4cf1-b5bb-b68406d92222");
service.pay(payment_3,null); //findByOrderID
service.addMoney(payment_1,null); //addMoney
service.addMoney(payment_2,null); //addMoney*/
}
}
| 2,259 | 33.769231 | 69 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/repository/AddMoneyRepository.java
|
package com.trainticket.repository;
import com.trainticket.entity.Money;
import org.springframework.data.repository.CrudRepository;
/**
* @author fdse
*/
public interface AddMoneyRepository extends CrudRepository<Money,String> {
}
| 235 | 20.454545 | 74 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/repository/PaymentRepository.java
|
package com.trainticket.repository;
import com.trainticket.entity.Payment;
import org.springframework.data.repository.CrudRepository;
import java.util.List;
import java.util.Optional;
/**
* @author fdse
*/
public interface PaymentRepository extends CrudRepository<Payment,String> {
Optional<Payment> findById(String id);
Payment findByOrderId(String orderId);
@Override
List<Payment> findAll();
List<Payment> findByUserId(String userId);
}
| 469 | 19.434783 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/service/PaymentService.java
|
package com.trainticket.service;
import com.trainticket.entity.Payment;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
/**
* @author Chenjie
* @date 2017/4/3
*/
public interface PaymentService {
Response pay(Payment info, HttpHeaders headers);
Response addMoney(Payment info, HttpHeaders headers);
Response query(HttpHeaders headers);
void initPayment(Payment payment,HttpHeaders headers);
}
| 455 | 19.727273 | 58 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/main/java/com/trainticket/service/PaymentServiceImpl.java
|
package com.trainticket.service;
import com.trainticket.entity.Money;
import com.trainticket.entity.Payment;
import com.trainticket.repository.AddMoneyRepository;
import com.trainticket.repository.PaymentRepository;
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 java.util.List;
import java.util.Optional;
/**
* @author Administrator
* @date 2017/6/23.
*/
@Service
public class PaymentServiceImpl implements PaymentService{
@Autowired
PaymentRepository paymentRepository;
@Autowired
AddMoneyRepository addMoneyRepository;
private static final Logger LOGGER = LoggerFactory.getLogger(PaymentServiceImpl.class);
@Override
public Response pay(Payment info, HttpHeaders headers){
if(paymentRepository.findByOrderId(info.getOrderId()) == null){
Payment payment = new Payment();
payment.setOrderId(info.getOrderId());
payment.setPrice(info.getPrice());
payment.setUserId(info.getUserId());
paymentRepository.save(payment);
return new Response<>(1, "Pay Success", null);
}else{
PaymentServiceImpl.LOGGER.warn("[pay][Pay Failed][Order not found with order id][PaymentId: {}, OrderId: {}]",info.getId(),info.getOrderId());
return new Response<>(0, "Pay Failed, order not found with order id" +info.getOrderId(), null);
}
}
@Override
public Response addMoney(Payment info, HttpHeaders headers){
Money addMoney = new Money();
addMoney.setUserId(info.getUserId());
addMoney.setMoney(info.getPrice());
addMoneyRepository.save(addMoney);
return new Response<>(1,"Add Money Success", addMoney);
}
@Override
public Response query(HttpHeaders headers){
List<Payment> payments = paymentRepository.findAll();
if(payments!= null && !payments.isEmpty()){
PaymentServiceImpl.LOGGER.info("[query][Find all payment Success][size:{}]",payments.size());
return new Response<>(1,"Query Success", payments);
}else {
PaymentServiceImpl.LOGGER.warn("[query][Find all payment warn][{}]","No content");
return new Response<>(0, "No Content", null);
}
}
@Override
public void initPayment(Payment payment, HttpHeaders headers){
Optional<Payment> paymentTemp = paymentRepository.findById(payment.getId());
if(!paymentTemp.isPresent()){
paymentRepository.save(payment);
PaymentServiceImpl.LOGGER.error("[initPayment][Init payment error][Payment not found][PaymentId: {}]",payment.getId());
}else{
PaymentServiceImpl.LOGGER.info("[initPayment][Init Payment Already Exists][PaymentId: {}]", payment.getId());
}
}
}
| 2,980 | 36.2625 | 154 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/test/java/com/trainticket/controller/PaymentControllerTest.java
|
package com.trainticket.controller;
import com.alibaba.fastjson.JSONObject;
import com.trainticket.entity.Payment;
import com.trainticket.service.PaymentService;
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;
@RunWith(JUnit4.class)
public class PaymentControllerTest {
@InjectMocks
private PaymentController paymentController;
@Mock
private PaymentService service;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(paymentController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/paymentservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Payment Service ] !"));
}
@Test
public void testPay() throws Exception {
Payment info = new Payment();
Mockito.when(service.pay(Mockito.any(Payment.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/paymentservice/payment").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testAddMoney() throws Exception {
Payment info = new Payment();
Mockito.when(service.addMoney(Mockito.any(Payment.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/paymentservice/payment/money").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQuery() throws Exception {
Mockito.when(service.query(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/paymentservice/payment"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 3,317 | 41.538462 | 169 |
java
|
train-ticket
|
train-ticket-master/ts-payment-service/src/test/java/com/trainticket/service/PaymentServiceImplTest.java
|
package com.trainticket.service;
import com.trainticket.entity.Money;
import com.trainticket.entity.Payment;
import com.trainticket.repository.AddMoneyRepository;
import com.trainticket.repository.PaymentRepository;
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.HttpHeaders;
import java.util.ArrayList;
import java.util.List;
@RunWith(JUnit4.class)
public class PaymentServiceImplTest {
@InjectMocks
private PaymentServiceImpl paymentServiceImpl;
@Mock
private PaymentRepository paymentRepository;
@Mock
private AddMoneyRepository addMoneyRepository;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testPay1() {
Payment info = new Payment();
Mockito.when(paymentRepository.findByOrderId(Mockito.anyString())).thenReturn(null);
Mockito.when(paymentRepository.save(Mockito.any(Payment.class))).thenReturn(null);
Response result = paymentServiceImpl.pay(info, headers);
Assert.assertEquals(new Response<>(1, "Pay Success", null), result);
}
@Test
public void testPay2() {
Payment info = new Payment();
Mockito.when(paymentRepository.findByOrderId(Mockito.anyString())).thenReturn(info);
Response result = paymentServiceImpl.pay(info, headers);
Assert.assertEquals(new Response<>(0, "Pay Failed, order not found with order id", null), result);
}
@Test
public void testAddMoney() {
Payment info = new Payment();
Mockito.when(addMoneyRepository.save(Mockito.any(Money.class))).thenReturn(null);
Response result = paymentServiceImpl.addMoney(info, headers);
Assert.assertEquals(new Response<>(1,"Add Money Success", null), result);
}
@Test
public void testQuery1() {
List<Payment> payments = new ArrayList<>();
payments.add(new Payment());
Mockito.when(paymentRepository.findAll()).thenReturn(payments);
Response result = paymentServiceImpl.query(headers);
Assert.assertEquals(new Response<>(1,"Query Success", payments), result);
}
@Test
public void testQuery2() {
Mockito.when(paymentRepository.findAll()).thenReturn(null);
Response result = paymentServiceImpl.query(headers);
Assert.assertEquals(new Response<>(0, "No Content", null), result);
}
@Test
public void testInitPayment1() {
Payment payment = new Payment();
Mockito.when(paymentRepository.findById(Mockito.anyString())).thenReturn(null);
Mockito.when(paymentRepository.save(Mockito.any(Payment.class))).thenReturn(null);
paymentServiceImpl.initPayment(payment, headers);
Mockito.verify(paymentRepository, Mockito.times(1)).save(Mockito.any(Payment.class));
}
@Test
public void testInitPayment2() {
Payment payment = new Payment();
Mockito.when(paymentRepository.findById(Mockito.anyString())).thenReturn(java.util.Optional.of(payment));
Mockito.when(paymentRepository.save(Mockito.any(Payment.class))).thenReturn(null);
paymentServiceImpl.initPayment(payment, headers);
Mockito.verify(paymentRepository, Mockito.times(0)).save(Mockito.any(Payment.class));
}
}
| 3,588 | 34.534653 | 113 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/main/java/preserveOther/PreserveOtherApplication.java
|
package preserveOther;
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 PreserveOtherApplication {
public static void main(String[] args) {
SpringApplication.run(PreserveOtherApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,202 | 31.513514 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/main/java/preserveOther/config/Queues.java
|
package preserveOther.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Queues {
public final static String queueName = "email";
@Bean
public Queue emailQueue() {
return new Queue(queueName);
}
}
| 367 | 20.647059 | 60 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/main/java/preserveOther/config/SecurityConfig.java
|
package preserveOther.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/preserveotherservice/**").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,262 | 38.792683 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/main/java/preserveOther/controller/PreserveOtherController.java
|
package preserveOther.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.OrderTicketsInfo;
import preserveOther.service.PreserveOtherService;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/preserveotherservice")
public class PreserveOtherController {
@Autowired
private PreserveOtherService preserveService;
private static final Logger LOGGER = LoggerFactory.getLogger(PreserveOtherController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ PreserveOther Service ] !";
}
@CrossOrigin(origins = "*")
@PostMapping(value = "/preserveOther")
public HttpEntity preserve(@RequestBody OrderTicketsInfo oti,
@RequestHeader HttpHeaders headers) {
PreserveOtherController.LOGGER.info("[preserve][Preserve Account order][from {} to {} at {}]", oti.getFrom(), oti.getTo(), oti.getDate());
return ok(preserveService.preserve(oti, headers));
}
}
| 1,297 | 31.45 | 146 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/main/java/preserveOther/mq/RabbitSend.java
|
package preserveOther.mq;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import preserveOther.config.Queues;
@Component
public class RabbitSend {
@Autowired
private AmqpTemplate rabbitTemplate;
private static final Logger logger = LoggerFactory.getLogger(RabbitSend.class);
public void send(String val) {
logger.info("send info to mq:" + val);
this.rabbitTemplate.convertAndSend(Queues.queueName, val);
}
}
| 624 | 23.038462 | 83 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/main/java/preserveOther/service/PreserveOtherService.java
|
package preserveOther.service;
import edu.fudan.common.entity.OrderTicketsInfo;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
/**
* @author fdse
*/
public interface PreserveOtherService {
Response preserve(OrderTicketsInfo oti, HttpHeaders headers);
}
| 300 | 19.066667 | 65 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/main/java/preserveOther/service/PreserveOtherServiceImpl.java
|
package preserveOther.service;
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 preserveOther.mq.RabbitSend;
import java.util.Date;
import java.util.List;
import java.util.UUID;
/**
* @author fdse
*/
@Service
public class PreserveOtherServiceImpl implements PreserveOtherService {
@Autowired
private RestTemplate restTemplate;
@Autowired
private RabbitSend sendService;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(PreserveOtherServiceImpl.class);
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
@Override
public Response preserve(OrderTicketsInfo oti, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[preserve][Verify Login] Success");
//1.detect ticket scalper
//PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 1][Check Security]");
Response result = checkSecurity(oti.getAccountId(), httpHeaders);
if (result.getStatus() == 0) {
PreserveOtherServiceImpl.LOGGER.error("[preserve][Step 1][Check Security Fail][AccountId: {}]",oti.getAccountId());
return new Response<>(0, result.getMsg(), null);
}
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 1][Check Security Complete][AccountId: {}]",oti.getAccountId());
//2.Querying contact information -- modification, mediated by the underlying information micro service
//PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 2][Find contacts][Contacts Id: {}]", oti.getContactsId());
Response<Contacts> gcr = getContactsById(oti.getContactsId(), httpHeaders);
if (gcr.getStatus() == 0) {
PreserveOtherServiceImpl.LOGGER.error("[preserve][Step 2][Find Contacts Fail][ContactsId: {},message: {}]",oti.getContactsId(),gcr.getMsg());
return new Response<>(0, gcr.getMsg(), null);
}
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 2][Find contacts Complete][ContactsId: {}]",oti.getContactsId());
//3.Check the info of train and the number of remaining tickets
//PreserveOtherServiceImpl.LOGGER.info("[Step 3] Check tickets num");
TripAllDetailInfo gtdi = new TripAllDetailInfo();
gtdi.setFrom(oti.getFrom());
gtdi.setTo(oti.getTo());
gtdi.setTravelDate(oti.getDate());
gtdi.setTripId(oti.getTripId());
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 3][Check tickets num][TripId: {}]", oti.getTripId());
Response<TripAllDetail> response = getTripAllDetailInformation(gtdi, httpHeaders);
TripAllDetail gtdr = response.getData();
//LOGGER.info("TripAllDetail : " + gtdr.toString());
if (response.getStatus() == 0) {
PreserveOtherServiceImpl.LOGGER.error("[preserve][Step 3][Check tickets num][Search For Trip Detail Information error][TripId: {}, message: {}]", gtdi.getTripId(), response.getMsg());
return new Response<>(0, response.getMsg(), null);
} else {
TripResponse tripResponse = gtdr.getTripResponse();
//LOGGER.info("TripResponse : " + tripResponse.toString());
if (oti.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {
if (tripResponse.getConfortClass() == 0) {
PreserveOtherServiceImpl.LOGGER.warn("[preserve][Step 3][Check seat][Check seat is enough][TripId: {}]",oti.getTripId());
return new Response<>(0, "Seat Not Enough", null);
}
} else {
if (tripResponse.getEconomyClass() == SeatClass.SECONDCLASS.getCode() && tripResponse.getConfortClass() == 0) {
PreserveOtherServiceImpl.LOGGER.warn("[preserve][Step 3][Check seat][Check seat is Not enough][TripId: {}]",oti.getTripId());
return new Response<>(0, "Check Seat Not Enough", null);
}
}
}
Trip trip = gtdr.getTrip();
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 3][Check tickets num][Tickets Enough]");
//4.send the order request and set the order information
//PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 4][Do Order]");
Contacts contacts = gcr.getData();
Order order = new Order();
String orderId = UUID.randomUUID().toString();
order.setId(orderId);
order.setTrainNumber(oti.getTripId());
order.setAccountId(oti.getAccountId());
String fromStationName = oti.getFrom();
String toStationName = oti.getTo();
order.setFrom(fromStationName);
order.setTo(toStationName);
order.setBoughtDate(StringUtils.Date2String(new Date()));
order.setStatus(OrderStatus.NOTPAID.getCode());
order.setContactsDocumentNumber(contacts.getDocumentNumber());
order.setContactsName(contacts.getName());
order.setDocumentType(contacts.getDocumentType());
Travel query = new Travel();
query.setTrip(trip);
query.setStartPlace(oti.getFrom());
query.setEndPlace(oti.getTo());
query.setDepartureTime(StringUtils.Date2String(new Date()));
HttpEntity requestEntity = new HttpEntity(query, httpHeaders);
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<TravelResult>>() {
});
if(re.getBody().getStatus() == 0){
PreserveOtherServiceImpl.LOGGER.info("[Preserve 3][Get basic travel response status is 0][response is: {}]", re.getBody());
return new Response<>(0, re.getBody().getMsg(), null);
}
TravelResult resultForTravel = re.getBody().getData();
order.setSeatClass(oti.getSeatType());
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 4][Do Order][Travel Date][Date is: {}]", oti.getDate().toString());
order.setTravelDate(oti.getDate());
order.setTravelTime(gtdr.getTripResponse().getStartTime());
//Dispatch the seat
List<String> stationList = resultForTravel.getRoute().getStations();
if (oti.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {
int firstClassTotalNum = resultForTravel.getTrainType().getConfortClass();
Ticket ticket =
dipatchSeat(oti.getDate(),
order.getTrainNumber(), fromStationName, toStationName,
SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, stationList, httpHeaders);
order.setSeatClass(SeatClass.FIRSTCLASS.getCode());
order.setSeatNumber("" + ticket.getSeatNo());
order.setPrice(resultForTravel.getPrices().get("confortClass"));
} else {
int secondClassTotalNum = resultForTravel.getTrainType().getEconomyClass();
Ticket ticket =
dipatchSeat(oti.getDate(),
order.getTrainNumber(), fromStationName, toStationName,
SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, stationList, httpHeaders);
order.setSeatClass(SeatClass.SECONDCLASS.getCode());
order.setSeatNumber("" + ticket.getSeatNo());
order.setPrice(resultForTravel.getPrices().get("economyClass"));
}
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 4][Do Order][Order Price][Price is: {}]", order.getPrice());
Response<Order> cor = createOrder(order, httpHeaders);
if (cor.getStatus() == 0) {
PreserveOtherServiceImpl.LOGGER.error("[preserve][Step 4][Do Order][Create Order Fail][OrderId: {}, Reason: {}]", order.getId(), cor.getMsg());
return new Response<>(0, cor.getMsg(), null);
}
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 4][Do Order][Do Order Complete]");
Response returnResponse = new Response<>(1, "Success.", cor.getMsg());
//5.Check insurance options
if (oti.getAssurance() == 0) {
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 5][Buy Assurance][Do not need to buy assurance]");
} else {
Response<Assurance> addAssuranceResult = addAssuranceForOrder(
oti.getAssurance(), cor.getData().getId().toString(), httpHeaders);
if (addAssuranceResult.getStatus() == 1) {
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 5][Buy Assurance][Preserve Buy Assurance Success]");
} else {
PreserveOtherServiceImpl.LOGGER.warn("[preserve][Step 5][Buy Assurance][Buy Assurance Fail][assurance: {}, OrderId: {}]", oti.getAssurance(),cor.getData().getId());
returnResponse.setMsg("Success.But Buy Assurance Fail.");
}
}
//6.Increase the food order
if (oti.getFoodType() != 0) {
FoodOrder foodOrder = new FoodOrder();
foodOrder.setOrderId(cor.getData().getId());
foodOrder.setFoodType(oti.getFoodType());
foodOrder.setFoodName(oti.getFoodName());
foodOrder.setPrice(oti.getFoodPrice());
if (oti.getFoodType() == 2) {
foodOrder.setStationName(oti.getStationName());
foodOrder.setStoreName(oti.getStoreName());
}
Response afor = createFoodOrder(foodOrder, httpHeaders);
if (afor.getStatus() == 1) {
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 6][Buy Food][Buy Food Success]");
} else {
PreserveOtherServiceImpl.LOGGER.error("[preserve][Step 6][Buy Food][Buy Food Fail][OrderId: {}]",cor.getData().getId());
returnResponse.setMsg("Success.But Buy Food Fail.");
}
} else {
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 6][Buy Food][Do not need to buy food]");
}
//7.add consign
if (null != oti.getConsigneeName() && !"".equals(oti.getConsigneeName())) {
Consign consignRequest = new Consign();
consignRequest.setOrderId(cor.getData().getId());
consignRequest.setAccountId(cor.getData().getAccountId());
consignRequest.setHandleDate(oti.getHandleDate());
consignRequest.setTargetDate(cor.getData().getTravelDate().toString());
consignRequest.setFrom(cor.getData().getFrom());
consignRequest.setTo(cor.getData().getTo());
consignRequest.setConsignee(oti.getConsigneeName());
consignRequest.setPhone(oti.getConsigneePhone());
consignRequest.setWeight(oti.getConsigneeWeight());
consignRequest.setWithin(oti.isWithin());
//LOGGER.info("CONSIGN INFO : " + consignRequest.toString());
Response icresult = createConsign(consignRequest, httpHeaders);
if (icresult.getStatus() == 1) {
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 7][Add Consign][Consign Success]");
} else {
PreserveOtherServiceImpl.LOGGER.error("[preserve][Step 7][Add Consign][Preserve Consign Fail][OrderId: {}]", cor.getData().getId());
returnResponse.setMsg("Consign Fail.");
}
} else {
PreserveOtherServiceImpl.LOGGER.info("[preserve][Step 7][Add Consign][Do not need to consign]");
}
//8.send notification
User getUser = getAccount(order.getAccountId().toString(), httpHeaders);
NotifyInfo notifyInfo = new NotifyInfo();
notifyInfo.setDate(new Date().toString());
notifyInfo.setEmail(getUser.getEmail());
notifyInfo.setStartPlace(order.getFrom());
notifyInfo.setEndPlace(order.getTo());
notifyInfo.setUsername(getUser.getUserName());
notifyInfo.setSeatNumber(order.getSeatNumber());
notifyInfo.setOrderNumber(order.getId().toString());
notifyInfo.setPrice(order.getPrice());
notifyInfo.setSeatClass(SeatClass.getNameByCode(order.getSeatClass()));
notifyInfo.setStartTime(order.getTravelTime().toString());
// TODO: change to async message serivce
// sendEmail(notifyInfo, httpHeaders);
return returnResponse;
}
public Ticket dipatchSeat(String date, String tripId, String startStationId, String endStataionId, int seatType, int totalNum, List<String> stationList, HttpHeaders httpHeaders) {
Seat seatRequest = new Seat();
seatRequest.setTravelDate(date);
seatRequest.setTrainNumber(tripId);
seatRequest.setStartStation(startStationId);
seatRequest.setSeatType(seatType);
seatRequest.setDestStation(endStataionId);
seatRequest.setTotalNum(totalNum);
seatRequest.setStations(stationList);
HttpEntity requestEntityTicket = new HttpEntity(seatRequest, httpHeaders);
String seat_service_url = getServiceUrl("ts-seat-service");
ResponseEntity<Response<Ticket>> reTicket = restTemplate.exchange(
seat_service_url + "/api/v1/seatservice/seats",
HttpMethod.POST,
requestEntityTicket,
new ParameterizedTypeReference<Response<Ticket>>() {
});
return reTicket.getBody().getData();
}
public boolean sendEmail(NotifyInfo notifyInfo, HttpHeaders httpHeaders) {
try {
String infoJson = JsonUtils.object2Json(notifyInfo);
sendService.send(infoJson);
PreserveOtherServiceImpl.LOGGER.info("[sendEmail][Send email to mq success]");
} catch (Exception e) {
PreserveOtherServiceImpl.LOGGER.error("[sendEmail][Send email to mq error] exception is:" + e);
return false;
}
return true;
}
public User getAccount(String accountId, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[getAccount][Cancel Order Service][Get Order By Id]");
HttpEntity requestEntitySendEmail = new HttpEntity(httpHeaders);
String user_service_url = getServiceUrl("ts-user-service");
ResponseEntity<Response<User>> getAccount = restTemplate.exchange(
user_service_url + "/api/v1/userservice/users/id/" + accountId,
HttpMethod.GET,
requestEntitySendEmail,
new ParameterizedTypeReference<Response<User>>() {
});
Response<User> result = getAccount.getBody();
return result.getData();
}
private Response<Assurance> addAssuranceForOrder(int assuranceType, String orderId, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[addAssuranceForOrder][Preserve Service][Add Assurance Type For Order]");
HttpEntity requestAddAssuranceResult = new HttpEntity(httpHeaders);
String assurance_service_url = getServiceUrl("ts-assurance-service");
ResponseEntity<Response<Assurance>> reAddAssuranceResult = restTemplate.exchange(
assurance_service_url + "/api/v1/assuranceservice/assurances/" + assuranceType + "/" + orderId,
HttpMethod.GET,
requestAddAssuranceResult,
new ParameterizedTypeReference<Response<Assurance>>() {
});
return reAddAssuranceResult.getBody();
}
private String queryForStationId(String stationName, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[queryForStationId][Preserve Other Service][Get Station By Name]");
HttpEntity requestQueryForStationId = new HttpEntity(httpHeaders);
String station_service_url = getServiceUrl("ts-station-service");
ResponseEntity<Response<String>> reQueryForStationId = restTemplate.exchange(
station_service_url + "/api/v1/stationservice/stations/id/" + stationName,
HttpMethod.GET,
requestQueryForStationId,
new ParameterizedTypeReference<Response<String>>() {
});
return reQueryForStationId.getBody().getData();
}
private Response checkSecurity(String accountId, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[checkSecurity][Preserve Other Service][Check Account Security]");
HttpEntity requestCheckResult = new HttpEntity(httpHeaders);
String security_service_url = getServiceUrl("ts-security-service");
ResponseEntity<Response> reCheckResult = restTemplate.exchange(
security_service_url + "/api/v1/securityservice/securityConfigs/" + accountId,
HttpMethod.GET,
requestCheckResult,
Response.class);
return reCheckResult.getBody();
}
private Response<TripAllDetail> getTripAllDetailInformation(TripAllDetailInfo gtdi, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[getTripAllDetailInformation][Preserve Other Service][Get Trip All Detail Information]");
HttpEntity requestGetTripAllDetailResult = new HttpEntity(gtdi, httpHeaders);
String travel2_service_url = getServiceUrl("ts-travel2-service");
ResponseEntity<Response<TripAllDetail>> reGetTripAllDetailResult = restTemplate.exchange(
travel2_service_url + "/api/v1/travel2service/trip_detail",
HttpMethod.POST,
requestGetTripAllDetailResult,
new ParameterizedTypeReference<Response<TripAllDetail>>() {
});
return reGetTripAllDetailResult.getBody();
}
private Response<Contacts> getContactsById(String contactsId, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[getContactsById][Preserve Other Service][Get Contacts By Id is]");
HttpEntity requestGetContactsResult = new HttpEntity(httpHeaders);
String contacts_service_url = getServiceUrl("ts-contacts-service");
ResponseEntity<Response<Contacts>> reGetContactsResult = restTemplate.exchange(
contacts_service_url + "/api/v1/contactservice/contacts/" + contactsId,
HttpMethod.GET,
requestGetContactsResult,
new ParameterizedTypeReference<Response<Contacts>>() {
});
return reGetContactsResult.getBody();
}
private Response<Order> createOrder(Order coi, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[createOrder][Preserve Other Service][Get Contacts By Id]");
HttpEntity requestEntityCreateOrderResult = new HttpEntity(coi, httpHeaders);
String order_other_service_url = getServiceUrl("ts-order-other-service");
ResponseEntity<Response<Order>> reCreateOrderResult = restTemplate.exchange(
order_other_service_url + "/api/v1/orderOtherService/orderOther",
HttpMethod.POST,
requestEntityCreateOrderResult,
new ParameterizedTypeReference<Response<Order>>() {
});
return reCreateOrderResult.getBody();
}
private Response createFoodOrder(FoodOrder afi, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[createFoodOrder][Preserve Service][Add Preserve food Order]");
HttpEntity requestEntityAddFoodOrderResult = new HttpEntity(afi, httpHeaders);
String food_service_url = getServiceUrl("ts-food-service");
ResponseEntity<Response> reAddFoodOrderResult = restTemplate.exchange(
food_service_url + "/api/v1/foodservice/orders",
HttpMethod.POST,
requestEntityAddFoodOrderResult,
Response.class);
return reAddFoodOrderResult.getBody();
}
private Response createConsign(Consign cr, HttpHeaders httpHeaders) {
PreserveOtherServiceImpl.LOGGER.info("[createConsign][Preserve Service][Add Condign]");
HttpEntity requestEntityResultForTravel = new HttpEntity(cr, httpHeaders);
String consign_service_url = getServiceUrl("ts-consign-service");
ResponseEntity<Response> reResultForTravel = restTemplate.exchange(
consign_service_url + "/api/v1/consignservice/consigns",
HttpMethod.POST,
requestEntityResultForTravel,
Response.class);
return reResultForTravel.getBody();
}
}
| 21,296 | 47.734554 | 195 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/test/java/preserveOther/controller/PreserveOtherControllerTest.java
|
package preserveOther.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.OrderTicketsInfo;
import preserveOther.service.PreserveOtherService;
@RunWith(JUnit4.class)
public class PreserveOtherControllerTest {
@InjectMocks
private PreserveOtherController preserveOtherController;
@Mock
private PreserveOtherService preserveService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(preserveOtherController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/preserveotherservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ PreserveOther Service ] !"));
}
@Test
public void testPreserve() throws Exception {
OrderTicketsInfo oti = new OrderTicketsInfo();
Mockito.when(preserveService.preserve(Mockito.any(OrderTicketsInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(oti);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/preserveotherservice/preserveOther").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 2,286 | 38.431034 | 175 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-other-service/src/test/java/preserveOther/service/PreserveOtherServiceImplTest.java
|
package preserveOther.service;
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 edu.fudan.common.entity.*;
import java.util.Date;
import java.util.HashMap;
import java.util.UUID;
@RunWith(JUnit4.class)
public class PreserveOtherServiceImplTest {
@InjectMocks
private PreserveOtherServiceImpl preserveOtherServiceImpl;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
private HttpEntity requestEntity = new HttpEntity(headers);
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testPreserve() {
OrderTicketsInfo oti = OrderTicketsInfo.builder()
.accountId(UUID.randomUUID().toString())
.contactsId(UUID.randomUUID().toString())
.from("from_station")
.to("to_station")
.date(StringUtils.Date2String(new Date()))
.handleDate("handle_date")
.tripId("G1255")
.seatType(2)
.assurance(1)
.foodType(1)
.foodName("food_name")
.foodPrice(1.0)
.stationName("station_name")
.storeName("store_name")
.consigneeName("consignee_name")
.consigneePhone("123456789")
.consigneeWeight(1.0)
.isWithin(true)
.build();
//response for checkSecurity()、createFoodOrder()、createConsign()
Response response1 = new Response<>(1, null, null);
ResponseEntity<Response> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
//response for sendEmail()
ResponseEntity<Boolean> re10 = new ResponseEntity<>(true, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re1).thenReturn(re1).thenReturn(re1).thenReturn(re10);
//response for getContactsById()
Contacts contacts = new Contacts();
contacts.setDocumentNumber("document_number");
contacts.setName("name");
contacts.setDocumentType(1);
Response<Contacts> response2 = new Response<>(1, null, contacts);
ResponseEntity<Response<Contacts>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
//response for getTripAllDetailInformation()
TripResponse tripResponse = new TripResponse();
tripResponse.setConfortClass(1);
tripResponse.setStartTime(StringUtils.Date2String(new Date()));
TripAllDetail tripAllDetail = new TripAllDetail(true, "message", tripResponse, new Trip());
Response<TripAllDetail> response3 = new Response<>(1, null, tripAllDetail);
ResponseEntity<Response<TripAllDetail>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
//response for queryForStationId()
Response<String> response4 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re4 = new ResponseEntity<>(response4, HttpStatus.OK);
//response for travel result
TravelResult travelResult = new TravelResult();
travelResult.setPrices( new HashMap<String, String>(){{ put("confortClass", "1.0"); }} );
Response<TravelResult> response5 = new Response<>(null, null, travelResult);
ResponseEntity<Response<TravelResult>> re5 = new ResponseEntity<>(response5, HttpStatus.OK);
//response for dipatchSeat()
Ticket ticket = new Ticket();
ticket.setSeatNo(1);
Response<Ticket> response6 = new Response<>(null, null, ticket);
ResponseEntity<Response<Ticket>> re6 = new ResponseEntity<>(response6, HttpStatus.OK);
//response for createOrder()
Order order = new Order();
order.setId(UUID.randomUUID().toString());
order.setAccountId(UUID.randomUUID().toString());
order.setTravelDate(StringUtils.Date2String(new Date()));
order.setFrom("from_station");
order.setTo("to_station");
Response<Order> response7 = new Response<>(1, null, order);
ResponseEntity<Response<Order>> re7 = new ResponseEntity<>(response7, HttpStatus.OK);
//response for addAssuranceForOrder()
Response<Assurance> response8 = new Response<>(1, null, null);
ResponseEntity<Response<Assurance>> re8 = new ResponseEntity<>(response8, HttpStatus.OK);
//response for getAccount()
User user = new User();
user.setEmail("email");
user.setUserName("user_name");
Response<User> response9 = new Response<>(1, null, user);
ResponseEntity<Response<User>> re9 = new ResponseEntity<>(response9, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re2).thenReturn(re3).thenReturn(re4).thenReturn(re4).thenReturn(re5).thenReturn(re6).thenReturn(re7).thenReturn(re8).thenReturn(re9);
Response result = preserveOtherServiceImpl.preserve(oti, headers);
Assert.assertEquals(new Response<>(1, "Success.", null), result);
}
@Test
public void testDipatchSeat() {
long mills = System.currentTimeMillis();
Seat seatRequest = new Seat(StringUtils.Date2String(new Date()), "G1234", "start_station", "dest_station", 2, 100, null);
HttpEntity requestEntityTicket = new HttpEntity<>(seatRequest, headers);
Response<Ticket> response = new Response<>();
ResponseEntity<Response<Ticket>> reTicket = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-seat-service:18898/api/v1/seatservice/seats",
HttpMethod.POST,
requestEntityTicket,
new ParameterizedTypeReference<Response<Ticket>>() {
})).thenReturn(reTicket);
Ticket result = preserveOtherServiceImpl.dipatchSeat(StringUtils.Date2String(new Date()), "G1234", "start_station", "dest_station", 2, 100, null, headers);
Assert.assertNull(result);
}
@Test
public void testSendEmail() {
NotifyInfo notifyInfo = new NotifyInfo();
HttpEntity requestEntitySendEmail = new HttpEntity<>(notifyInfo, headers);
ResponseEntity<Boolean> reSendEmail = new ResponseEntity<>(true, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-notification-service:17853/api/v1/notifyservice/notification/preserve_success",
HttpMethod.POST,
requestEntitySendEmail,
Boolean.class)).thenReturn(reSendEmail);
boolean result = preserveOtherServiceImpl.sendEmail(notifyInfo, headers);
Assert.assertTrue(result);
}
@Test
public void testGetAccount() {
Response<User> response = new Response<>();
ResponseEntity<Response<User>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-user-service:12342/api/v1/userservice/users/id/1",
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<User>>() {
})).thenReturn(re);
User result = preserveOtherServiceImpl.getAccount("1", headers);
Assert.assertNull(result);
}
}
| 8,073 | 41.946809 | 163 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/main/java/preserve/PreserveApplication.java
|
package preserve;
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 PreserveApplication {
public static void main(String[] args) {
SpringApplication.run(PreserveApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,187 | 31.108108 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/main/java/preserve/config/Queues.java
|
package preserve.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Queues {
public final static String queueName = "email";
@Bean
public Queue emailQueue() {
return new Queue(queueName);
}
}
| 362 | 20.352941 | 60 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/main/java/preserve/config/SecurityConfig.java
|
package preserve.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/preserveservice/**").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-preserve-service/src/main/java/preserve/controller/PreserveController.java
|
package preserve.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.*;
import preserve.service.PreserveService;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/preserveservice")
public class PreserveController {
@Autowired
private PreserveService preserveService;
private static final Logger LOGGER = LoggerFactory.getLogger(PreserveController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ Preserve Service ] !";
}
@CrossOrigin(origins = "*")
@PostMapping(value = "/preserve")
public HttpEntity preserve(@RequestBody OrderTicketsInfo oti,
@RequestHeader HttpHeaders headers) {
PreserveController.LOGGER.info("[preserve][Preserve Account order][from {} to {} at {}]", oti.getFrom(), oti.getTo(), oti.getDate());
return ok(preserveService.preserve(oti, headers));
}
}
| 1,232 | 29.825 | 141 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/main/java/preserve/mq/RabbitSend.java
|
package preserve.mq;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import preserve.config.Queues;
@Component
public class RabbitSend {
@Autowired
private AmqpTemplate rabbitTemplate;
private static final Logger logger = LoggerFactory.getLogger(RabbitSend.class);
public void send(String val) {
logger.info("send info to mq:" + val);
this.rabbitTemplate.convertAndSend(Queues.queueName, val);
}
}
| 612 | 24.541667 | 83 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/main/java/preserve/service/PreserveService.java
|
package preserve.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import edu.fudan.common.entity.OrderTicketsInfo;
/**
* @author fdse
*/
public interface PreserveService {
Response preserve(OrderTicketsInfo oti, HttpHeaders headers);
}
| 289 | 19.714286 | 65 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/main/java/preserve/service/PreserveServiceImpl.java
|
package preserve.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 preserve.mq.RabbitSend;
import java.util.Date;
import java.util.List;
import java.util.UUID;
/**
* @author fdse
*/
@Service
public class PreserveServiceImpl implements PreserveService {
@Autowired
private RestTemplate restTemplate;
@Autowired
private RabbitSend sendService;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(PreserveServiceImpl.class);
private String getServiceUrl(String serviceName) {
return "http://" + serviceName; }
@Override
public Response preserve(OrderTicketsInfo oti, HttpHeaders headers) {
//1.detect ticket scalper
//PreserveServiceImpl.LOGGER.info("[Step 1] Check Security");
Response result = checkSecurity(oti.getAccountId(), headers);
if (result.getStatus() == 0) {
PreserveServiceImpl.LOGGER.error("[preserve][Step 1][Check Security Fail][AccountId: {}]",oti.getAccountId());
return new Response<>(0, result.getMsg(), null);
}
PreserveServiceImpl.LOGGER.info("[preserve][Step 1][Check Security Complete][AccountId: {}]",oti.getAccountId());
//2.Querying contact information -- modification, mediated by the underlying information micro service
//PreserveServiceImpl.LOGGER.info("[Step 2] Find contacts");
//PreserveServiceImpl.LOGGER.info("[Step 2] Contacts Id: {}", oti.getContactsId());
Response<Contacts> gcr = getContactsById(oti.getContactsId(), headers);
if (gcr.getStatus() == 0) {
PreserveServiceImpl.LOGGER.error("[preserve][Step 2][Find Contacts Fail][ContactsId: {},message: {}]",oti.getContactsId(),gcr.getMsg());
return new Response<>(0, gcr.getMsg(), null);
}
PreserveServiceImpl.LOGGER.info("[preserve][Step 2][Find contacts Complete][ContactsId: {}]",oti.getContactsId());
//3.Check the info of train and the number of remaining tickets
//PreserveServiceImpl.LOGGER.info("[Step 3] Check tickets num");
TripAllDetailInfo gtdi = new TripAllDetailInfo();
gtdi.setFrom(oti.getFrom());
gtdi.setTo(oti.getTo());
gtdi.setTravelDate(oti.getDate());
gtdi.setTripId(oti.getTripId());
PreserveServiceImpl.LOGGER.info("[preserve][Step 3][Check tickets num][TripId: {}]", oti.getTripId());
Response<TripAllDetail> response = getTripAllDetailInformation(gtdi, headers);
TripAllDetail gtdr = response.getData();
//LOGGER.info("TripAllDetail:" + gtdr.toString());
if (response.getStatus() == 0) {
PreserveServiceImpl.LOGGER.error("[preserve][Step 3][Check tickets num][Search For Trip Detail Information error][TripId: {}, message: {}]", gtdi.getTripId(), response.getMsg());
return new Response<>(0, response.getMsg(), null);
} else {
TripResponse tripResponse = gtdr.getTripResponse();
//LOGGER.info("TripResponse:" + tripResponse.toString());
if (oti.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {
if (tripResponse.getConfortClass() == 0) {
PreserveServiceImpl.LOGGER.warn("[preserve][Step 3][Check seat][Check seat is enough][TripId: {}]",oti.getTripId());
return new Response<>(0, "Seat Not Enough", null);
}
} else {
if (tripResponse.getEconomyClass() == SeatClass.SECONDCLASS.getCode() && tripResponse.getConfortClass() == 0) {
PreserveServiceImpl.LOGGER.warn("[preserve][Step 3][Check seat][Check seat is Not enough][TripId: {}]",oti.getTripId());
return new Response<>(0, "Seat Not Enough", null);
}
}
}
Trip trip = gtdr.getTrip();
PreserveServiceImpl.LOGGER.info("[preserve][Step 3][Check tickets num][Tickets Enough]");
//4.send the order request and set the order information
//PreserveServiceImpl.LOGGER.info("[Step 4] Do Order");
Contacts contacts = gcr.getData();
Order order = new Order();
UUID orderId = UUID.randomUUID();
order.setId(orderId.toString());
order.setTrainNumber(oti.getTripId());
order.setAccountId(oti.getAccountId());
String fromStationName = oti.getFrom();
String toStationName = oti.getTo();
order.setFrom(fromStationName);
order.setTo(toStationName);
order.setBoughtDate(StringUtils.Date2String(new Date()));
order.setStatus(OrderStatus.NOTPAID.getCode());
order.setContactsDocumentNumber(contacts.getDocumentNumber());
order.setContactsName(contacts.getName());
order.setDocumentType(contacts.getDocumentType());
Travel query = new Travel();
query.setTrip(trip);
query.setStartPlace(oti.getFrom());
query.setEndPlace(oti.getTo());
query.setDepartureTime(StringUtils.Date2String(new Date()));
HttpEntity requestEntity = new HttpEntity(query, headers);
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<TravelResult>>() {
});
if(re.getBody().getStatus() == 0){
PreserveServiceImpl.LOGGER.info("[Preserve 3][Get basic travel response status is 0][response is: {}]", re.getBody());
return new Response<>(0, re.getBody().getMsg(), null);
}
TravelResult resultForTravel = re.getBody().getData();
order.setSeatClass(oti.getSeatType());
PreserveServiceImpl.LOGGER.info("[preserve][Step 4][Do Order][Travel Date][Date is: {}]", oti.getDate().toString());
order.setTravelDate(oti.getDate());
order.setTravelTime(gtdr.getTripResponse().getStartTime());
//Dispatch the seat
List<String> stationList = resultForTravel.getRoute().getStations();
if (oti.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {
int firstClassTotalNum = resultForTravel.getTrainType().getConfortClass();
Ticket ticket =
dipatchSeat(oti.getDate(),
order.getTrainNumber(), fromStationName, toStationName,
SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, stationList, headers);
order.setSeatNumber("" + ticket.getSeatNo());
order.setSeatClass(SeatClass.FIRSTCLASS.getCode());
order.setPrice(resultForTravel.getPrices().get("confortClass"));
} else {
int secondClassTotalNum = resultForTravel.getTrainType().getEconomyClass();
Ticket ticket =
dipatchSeat(oti.getDate(),
order.getTrainNumber(), fromStationName, toStationName,
SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, stationList, headers);
order.setSeatClass(SeatClass.SECONDCLASS.getCode());
order.setSeatNumber("" + ticket.getSeatNo());
order.setPrice(resultForTravel.getPrices().get("economyClass"));
}
PreserveServiceImpl.LOGGER.info("[preserve][Step 4][Do Order][Order Price][Price is: {}]", order.getPrice());
Response<Order> cor = createOrder(order, headers);
if (cor.getStatus() == 0) {
PreserveServiceImpl.LOGGER.error("[preserve][Step 4][Do Order][Create Order Fail][OrderId: {}, Reason: {}]", order.getId(), cor.getMsg());
return new Response<>(0, cor.getMsg(), null);
}
PreserveServiceImpl.LOGGER.info("[preserve][Step 4][Do Order][Do Order Complete]");
Response returnResponse = new Response<>(1, "Success.", cor.getMsg());
//5.Check insurance options
if (oti.getAssurance() == 0) {
PreserveServiceImpl.LOGGER.info("[preserve][Step 5][Buy Assurance][Do not need to buy assurance]");
} else {
Response addAssuranceResult = addAssuranceForOrder(
oti.getAssurance(), cor.getData().getId().toString(), headers);
if (addAssuranceResult.getStatus() == 1) {
PreserveServiceImpl.LOGGER.info("[preserve][Step 5][Buy Assurance][Preserve Buy Assurance Success]");
} else {
PreserveServiceImpl.LOGGER.warn("[preserve][Step 5][Buy Assurance][Buy Assurance Fail][assurance: {}, OrderId: {}]", oti.getAssurance(),cor.getData().getId());
returnResponse.setMsg("Success.But Buy Assurance Fail.");
}
}
//6.Increase the food order
if (oti.getFoodType() != 0) {
FoodOrder foodOrder = new FoodOrder();
foodOrder.setOrderId(cor.getData().getId());
foodOrder.setFoodType(oti.getFoodType());
foodOrder.setFoodName(oti.getFoodName());
foodOrder.setPrice(oti.getFoodPrice());
if (oti.getFoodType() == 2) {
foodOrder.setStationName(oti.getStationName());
foodOrder.setStoreName(oti.getStoreName());
//PreserveServiceImpl.LOGGER.info("foodstore= {} {} {}", foodOrder.getFoodType(), foodOrder.getStationName(), foodOrder.getStoreName());
}
Response afor = createFoodOrder(foodOrder, headers);
if (afor.getStatus() == 1) {
PreserveServiceImpl.LOGGER.info("[preserve][Step 6][Buy Food][Buy Food Success]");
} else {
PreserveServiceImpl.LOGGER.error("[preserve][Step 6][Buy Food][Buy Food Fail][OrderId: {}]",cor.getData().getId());
returnResponse.setMsg("Success.But Buy Food Fail.");
}
} else {
PreserveServiceImpl.LOGGER.info("[preserve][Step 6][Buy Food][Do not need to buy food]");
}
//7.add consign
if (null != oti.getConsigneeName() && !"".equals(oti.getConsigneeName())) {
Consign consignRequest = new Consign();
consignRequest.setOrderId(cor.getData().getId());
consignRequest.setAccountId(cor.getData().getAccountId());
consignRequest.setHandleDate(oti.getHandleDate());
consignRequest.setTargetDate(cor.getData().getTravelDate().toString());
consignRequest.setFrom(cor.getData().getFrom());
consignRequest.setTo(cor.getData().getTo());
consignRequest.setConsignee(oti.getConsigneeName());
consignRequest.setPhone(oti.getConsigneePhone());
consignRequest.setWeight(oti.getConsigneeWeight());
consignRequest.setWithin(oti.isWithin());
LOGGER.info("CONSIGN INFO : " +consignRequest.toString());
Response icresult = createConsign(consignRequest, headers);
if (icresult.getStatus() == 1) {
PreserveServiceImpl.LOGGER.info("[preserve][Step 7][Add Consign][Consign Success]");
} else {
PreserveServiceImpl.LOGGER.error("[preserve][Step 7][Add Consign][Preserve Consign Fail][OrderId: {}]", cor.getData().getId());
returnResponse.setMsg("Consign Fail.");
}
} else {
PreserveServiceImpl.LOGGER.info("[preserve][Step 7][Add Consign][Do not need to consign]");
}
//8.send notification
User getUser = getAccount(order.getAccountId().toString(), headers);
NotifyInfo notifyInfo = new NotifyInfo();
notifyInfo.setDate(new Date().toString());
notifyInfo.setEmail(getUser.getEmail());
notifyInfo.setStartPlace(order.getFrom());
notifyInfo.setEndPlace(order.getTo());
notifyInfo.setUsername(getUser.getUserName());
notifyInfo.setSeatNumber(order.getSeatNumber());
notifyInfo.setOrderNumber(order.getId().toString());
notifyInfo.setPrice(order.getPrice());
notifyInfo.setSeatClass(SeatClass.getNameByCode(order.getSeatClass()));
notifyInfo.setStartTime(order.getTravelTime().toString());
// TODO: change to async message serivce
// sendEmail(notifyInfo, headers);
return returnResponse;
}
public Ticket dipatchSeat(String date, String tripId, String startStation, String endStataion, int seatType, int totalNum, List<String> stationList, HttpHeaders httpHeaders) {
Seat seatRequest = new Seat();
seatRequest.setTravelDate(date);
seatRequest.setTrainNumber(tripId);
seatRequest.setStartStation(startStation);
seatRequest.setDestStation(endStataion);
seatRequest.setSeatType(seatType);
seatRequest.setTotalNum(totalNum);
seatRequest.setStations(stationList);
HttpEntity requestEntityTicket = new HttpEntity(seatRequest, httpHeaders);
String seat_service_url = getServiceUrl("ts-seat-service");
ResponseEntity<Response<Ticket>> reTicket = restTemplate.exchange(
seat_service_url + "/api/v1/seatservice/seats",
HttpMethod.POST,
requestEntityTicket,
new ParameterizedTypeReference<Response<Ticket>>() {
});
return reTicket.getBody().getData();
}
public boolean sendEmail(NotifyInfo notifyInfo, HttpHeaders httpHeaders) {
try {
String infoJson = JsonUtils.object2Json(notifyInfo);
sendService.send(infoJson);
PreserveServiceImpl.LOGGER.info("[sendEmail][Send email to mq success]");
} catch (Exception e) {
PreserveServiceImpl.LOGGER.error("[sendEmail][Send email to mq error] exception is:" + e);
return false;
}
return true;
}
public User getAccount(String accountId, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[getAccount][Cancel Order Service][Get Order By Id]");
HttpEntity requestEntitySendEmail = new HttpEntity(httpHeaders);
String user_service_url = getServiceUrl("ts-user-service");
ResponseEntity<Response<User>> getAccount = restTemplate.exchange(
user_service_url + "/api/v1/userservice/users/id/" + accountId,
HttpMethod.GET,
requestEntitySendEmail,
new ParameterizedTypeReference<Response<User>>() {
});
Response<User> result = getAccount.getBody();
return result.getData();
}
private Response addAssuranceForOrder(int assuranceType, String orderId, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[addAssuranceForOrder][Preserve Service][Add Assurance Type For Order]");
HttpEntity requestAddAssuranceResult = new HttpEntity(httpHeaders);
String assurance_service_url = getServiceUrl("ts-assurance-service");
ResponseEntity<Response> reAddAssuranceResult = restTemplate.exchange(
assurance_service_url + "/api/v1/assuranceservice/assurances/" + assuranceType + "/" + orderId,
HttpMethod.GET,
requestAddAssuranceResult,
Response.class);
return reAddAssuranceResult.getBody();
}
private String queryForStationId(String stationName, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[queryForStationId][Preserve Other Service][Get Station By Name]");
HttpEntity requestQueryForStationId = new HttpEntity(httpHeaders);
String station_service_url = getServiceUrl("ts-station-service");
ResponseEntity<Response<String>> reQueryForStationId = restTemplate.exchange(
station_service_url + "/api/v1/stationservice/stations/id/" + stationName,
HttpMethod.GET,
requestQueryForStationId,
new ParameterizedTypeReference<Response<String>>() {
});
return reQueryForStationId.getBody().getData();
}
private Response checkSecurity(String accountId, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[checkSecurity][Preserve Other Service][Check Account Security]");
HttpEntity requestCheckResult = new HttpEntity(httpHeaders);
String security_service_url = getServiceUrl("ts-security-service");
ResponseEntity<Response> reCheckResult = restTemplate.exchange(
security_service_url + "/api/v1/securityservice/securityConfigs/" + accountId,
HttpMethod.GET,
requestCheckResult,
Response.class);
return reCheckResult.getBody();
}
private Response<TripAllDetail> getTripAllDetailInformation(TripAllDetailInfo gtdi, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[getTripAllDetailInformation][Preserve Other Service][Get Trip All Detail Information]");
HttpEntity requestGetTripAllDetailResult = new HttpEntity(gtdi, httpHeaders);
String travel_service_url = getServiceUrl("ts-travel-service");
ResponseEntity<Response<TripAllDetail>> reGetTripAllDetailResult = restTemplate.exchange(
travel_service_url + "/api/v1/travelservice/trip_detail",
HttpMethod.POST,
requestGetTripAllDetailResult,
new ParameterizedTypeReference<Response<TripAllDetail>>() {
});
return reGetTripAllDetailResult.getBody();
}
private Response<Contacts> getContactsById(String contactsId, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[getContactsById][Preserve Other Service][Get Contacts By Id is]");
HttpEntity requestGetContactsResult = new HttpEntity(httpHeaders);
String contacts_service_url = getServiceUrl("ts-contacts-service");
ResponseEntity<Response<Contacts>> reGetContactsResult = restTemplate.exchange(
contacts_service_url + "/api/v1/contactservice/contacts/" + contactsId,
HttpMethod.GET,
requestGetContactsResult,
new ParameterizedTypeReference<Response<Contacts>>() {
});
return reGetContactsResult.getBody();
}
private Response createOrder(Order coi, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[createOrder][Preserve Service][create order]");
HttpEntity requestEntityCreateOrderResult = new HttpEntity(coi, httpHeaders);
String order_service_url = getServiceUrl("ts-order-service");
ResponseEntity<Response<Order>> reCreateOrderResult = restTemplate.exchange(
order_service_url + "/api/v1/orderservice/order",
HttpMethod.POST,
requestEntityCreateOrderResult,
new ParameterizedTypeReference<Response<Order>>() {
});
return reCreateOrderResult.getBody();
}
private Response createFoodOrder(FoodOrder afi, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[createFoodOrder][Preserve Service][Add Preserve food Order]");
HttpEntity requestEntityAddFoodOrderResult = new HttpEntity(afi, httpHeaders);
String food_service_url = getServiceUrl("ts-food-service");
ResponseEntity<Response> reAddFoodOrderResult = restTemplate.exchange(
food_service_url + "/api/v1/foodservice/orders",
HttpMethod.POST,
requestEntityAddFoodOrderResult,
Response.class);
return reAddFoodOrderResult.getBody();
}
private Response createConsign(Consign cr, HttpHeaders httpHeaders) {
PreserveServiceImpl.LOGGER.info("[createConsign][Preserve Service][Add Condign");
HttpEntity requestEntityResultForTravel = new HttpEntity(cr, httpHeaders);
String consign_service_url = getServiceUrl("ts-consign-service");
ResponseEntity<Response> reResultForTravel = restTemplate.exchange(
consign_service_url + "/api/v1/consignservice/consigns",
HttpMethod.POST,
requestEntityResultForTravel,
Response.class);
return reResultForTravel.getBody();
}
}
| 21,066 | 47.541475 | 190 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/test/java/preserve/controller/PreserveControllerTest.java
|
package preserve.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.OrderTicketsInfo;
import preserve.service.PreserveService;
@RunWith(JUnit4.class)
public class PreserveControllerTest {
@InjectMocks
private PreserveController preserveController;
@Mock
private PreserveService preserveService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(preserveController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/preserveservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Preserve Service ] !"));
}
@Test
public void testPreserve() throws Exception {
OrderTicketsInfo oti = new OrderTicketsInfo();
Mockito.when(preserveService.preserve(Mockito.any(OrderTicketsInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(oti);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/preserveservice/preserve").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 2,226 | 37.396552 | 165 |
java
|
train-ticket
|
train-ticket-master/ts-preserve-service/src/test/java/preserve/service/PreserveServiceImplTest.java
|
package preserve.service;
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 edu.fudan.common.entity.*;
import java.util.Date;
import java.util.HashMap;
import java.util.UUID;
@RunWith(JUnit4.class)
public class PreserveServiceImplTest {
@InjectMocks
private PreserveServiceImpl preserveServiceImpl;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
private HttpEntity requestEntity = new HttpEntity(headers);
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testPreserve() {
OrderTicketsInfo oti = OrderTicketsInfo.builder()
.accountId(UUID.randomUUID().toString())
.contactsId(UUID.randomUUID().toString())
.from("from_station")
.to("to_station")
.date(StringUtils.Date2String(new Date()))
.handleDate("handle_date")
.tripId("G1255")
.seatType(2)
.assurance(1)
.foodType(1)
.foodName("food_name")
.foodPrice(1.0)
.stationName("station_name")
.storeName("store_name")
.consigneeName("consignee_name")
.consigneePhone("123456789")
.consigneeWeight(1.0)
.isWithin(true)
.build();
//response for checkSecurity()、addAssuranceForOrder()、createFoodOrder()、createConsign()
Response response1 = new Response<>(1, null, null);
ResponseEntity<Response> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
//response for sendEmail()
ResponseEntity<Boolean> re10 = new ResponseEntity<>(true, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re1).thenReturn(re1).thenReturn(re1).thenReturn(re1).thenReturn(re10);
//response for getContactsById()
Contacts contacts = new Contacts();
contacts.setDocumentNumber("document_number");
contacts.setName("name");
contacts.setDocumentType(1);
Response<Contacts> response2 = new Response<>(1, null, contacts);
ResponseEntity<Response<Contacts>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
//response for getTripAllDetailInformation()
TripResponse tripResponse = new TripResponse();
tripResponse.setConfortClass(1);
tripResponse.setStartTime(StringUtils.Date2String(new Date()));
TripAllDetail tripAllDetail = new TripAllDetail(true, "message", tripResponse, new Trip());
Response<TripAllDetail> response3 = new Response<>(1, null, tripAllDetail);
ResponseEntity<Response<TripAllDetail>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
//response for queryForStationId()
Response<String> response4 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re4 = new ResponseEntity<>(response4, HttpStatus.OK);
//response for travel result
TravelResult travelResult = new TravelResult();
travelResult.setPrices( new HashMap<String, String>(){{ put("confortClass", "1.0"); }} );
Response<TravelResult> response5 = new Response<>(null, null, travelResult);
ResponseEntity<Response<TravelResult>> re5 = new ResponseEntity<>(response5, HttpStatus.OK);
//response for dipatchSeat()
Ticket ticket = new Ticket();
ticket.setSeatNo(1);
Response<Ticket> response6 = new Response<>(null, null, ticket);
ResponseEntity<Response<Ticket>> re6 = new ResponseEntity<>(response6, HttpStatus.OK);
//response for createOrder()
Order order = new Order();
order.setId(UUID.randomUUID().toString());
order.setAccountId(UUID.randomUUID().toString());
order.setTravelDate(StringUtils.Date2String(new Date()));
order.setFrom("from_station");
order.setTo("to_station");
Response<Order> response7 = new Response<>(1, null, order);
ResponseEntity<Response<Order>> re7 = new ResponseEntity<>(response7, HttpStatus.OK);
//response for getAccount()
User user = new User();
user.setEmail("email");
user.setUserName("user_name");
Response<User> response9 = new Response<>(1, null, user);
ResponseEntity<Response<User>> re9 = new ResponseEntity<>(response9, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re2).thenReturn(re3).thenReturn(re4).thenReturn(re4).thenReturn(re5).thenReturn(re6).thenReturn(re7).thenReturn(re9);
Response result = preserveServiceImpl.preserve(oti, headers);
Assert.assertEquals(new Response<>(1, "Success.", null), result);
}
@Test
public void testDipatchSeat() {
long mills = System.currentTimeMillis();
Seat seatRequest = new Seat(StringUtils.Date2String(new Date()), "G1234", "start_station", "dest_station", 2, 100, null);
HttpEntity requestEntityTicket = new HttpEntity(seatRequest, headers);
Response<Ticket> response = new Response<>();
ResponseEntity<Response<Ticket>> reTicket = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-seat-service:18898/api/v1/seatservice/seats",
HttpMethod.POST,
requestEntityTicket,
new ParameterizedTypeReference<Response<Ticket>>() {
})).thenReturn(reTicket);
Ticket result = preserveServiceImpl.dipatchSeat(StringUtils.Date2String(new Date()), "G1234", "start_station", "dest_station", 2, 100, null, headers);
Assert.assertNull(result);
}
@Test
public void testSendEmail() {
NotifyInfo notifyInfo = new NotifyInfo();
HttpEntity requestEntitySendEmail = new HttpEntity(notifyInfo, headers);
ResponseEntity<Boolean> reSendEmail = new ResponseEntity<>(true, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-notification-service:17853/api/v1/notifyservice/notification/preserve_success",
HttpMethod.POST,
requestEntitySendEmail,
Boolean.class)).thenReturn(reSendEmail);
boolean result = preserveServiceImpl.sendEmail(notifyInfo, headers);
Assert.assertTrue(result);
}
@Test
public void testGetAccount() {
Response<User> response = new Response<>();
ResponseEntity<Response<User>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-user-service:12342/api/v1/userservice/users/id/1",
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<User>>() {
})).thenReturn(re);
User result = preserveServiceImpl.getAccount("1", headers);
Assert.assertNull(result);
}
}
| 7,836 | 41.592391 | 158 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/PriceApplication.java
|
package price;
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 PriceApplication {
public static void main(String[] args) {
SpringApplication.run(PriceApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,176 | 32.628571 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/config/SecurityConfig.java
|
package price.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 prices = "/api/v1/priceservice/prices";
/**
* 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/priceservice/**").permitAll()
.antMatchers(HttpMethod.POST, prices).hasAnyRole(admin)
.antMatchers(HttpMethod.DELETE, prices).hasAnyRole(admin)
.antMatchers(HttpMethod.PUT, prices).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,571 | 39.134831 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/controller/PriceController.java
|
package price.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.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import price.entity.PriceConfig;
import price.service.PriceService;
import java.util.List;
import java.util.Map;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/priceservice")
public class PriceController {
@Autowired
PriceService service;
private static final Logger LOGGER = LoggerFactory.getLogger(PriceController.class);
@GetMapping(path = "/prices/welcome")
public String home() {
return "Welcome to [ Price Service ] !";
}
@GetMapping(value = "/prices/{routeId}/{trainType}")
public HttpEntity query(@PathVariable String routeId, @PathVariable String trainType,
@RequestHeader HttpHeaders headers) {
PriceController.LOGGER.info("[findByRouteIdAndTrainType][Query price][RouteId: {}, TrainType: {}]",routeId,trainType);
return ok(service.findByRouteIdAndTrainType(routeId, trainType, headers));
}
@PostMapping(value = "/prices/byRouteIdsAndTrainTypes")
public HttpEntity query(@RequestBody List<String> ridsAndTts,
@RequestHeader HttpHeaders headers) {
PriceController.LOGGER.info("[findByRouteIdAndTrainType][Query price][routeId and Train Type: {}]", ridsAndTts);
return ok(service.findByRouteIdsAndTrainTypes(ridsAndTts, headers));
}
@GetMapping(value = "/prices")
public HttpEntity queryAll(@RequestHeader HttpHeaders headers) {
PriceController.LOGGER.info("[findAllPriceConfig][Query all prices]");
return ok(service.findAllPriceConfig(headers));
}
@PostMapping(value = "/prices")
public HttpEntity<?> create(@RequestBody PriceConfig info,
@RequestHeader HttpHeaders headers) {
PriceController.LOGGER.info("[createNewPriceConfig][Create price][RouteId: {}, TrainType: {}]",info.getRouteId(),info.getTrainType());
return new ResponseEntity<>(service.createNewPriceConfig(info, headers), HttpStatus.CREATED);
}
@DeleteMapping(value = "/prices/{pricesId}")
public HttpEntity delete(@PathVariable String pricesId, @RequestHeader HttpHeaders headers) {
PriceController.LOGGER.info("[deletePriceConfig][Delete price][PriceConfigId: {}]",pricesId);
return ok(service.deletePriceConfig(pricesId, headers));
}
@PutMapping(value = "/prices")
public HttpEntity update(@RequestBody PriceConfig info, @RequestHeader HttpHeaders headers) {
PriceController.LOGGER.info("[updatePriceConfig][Update price][PriceConfigId: {}]",info.getId());
return ok(service.updatePriceConfig(info, headers));
}
}
| 3,044 | 39.6 | 142 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/entity/PriceConfig.java
|
package price.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import javax.persistence.*;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@AllArgsConstructor
@Entity
@JsonIgnoreProperties(ignoreUnknown = true)
@Table(indexes = {@Index(name = "route_type_idx", columnList = "train_type, route_id", unique = true)})
public class PriceConfig {
@Id
@Column(length = 36)
private String id;
@Column(name="train_type")
private String trainType;
@Column(name="route_id", length = 36)
private String routeId;
private double basicPriceRate;
private double firstClassPriceRate;
public PriceConfig() {
//Empty Constructor
this.id = UUID.randomUUID().toString();
}
}
| 806 | 18.682927 | 103 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/init/InitData.java
|
package price.init;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import price.entity.PriceConfig;
import price.service.PriceService;
import java.util.UUID;
/**
* @author Chenjie Xu
* @date 2017/6/12.
*/
@Component
public class InitData implements CommandLineRunner {
@Autowired
PriceService service;
String gaoTieOne = "GaoTieOne";
String zhiDa = "ZhiDa";
@Override
public void run(String... args)throws Exception{
PriceConfig priceConfig = new PriceConfig();
priceConfig.setId(UUID.fromString("6d20b8cb-039c-474c-ae25-b6177ea41152").toString());
priceConfig.setRouteId("92708982-77af-4318-be25-57ccb0ff69ad");
priceConfig.setTrainType(gaoTieOne);
priceConfig.setBasicPriceRate(0.38);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("c5679b7e-4a54-4f52-9939-1ae86ba16fa7").toString());
priceConfig.setRouteId("aefcef3f-3f42-46e8-afd7-6cb2a928bd3d");
priceConfig.setTrainType(gaoTieOne);
priceConfig.setBasicPriceRate(0.5);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("719287d6-d3e7-4b54-9a92-71d039748b22").toString());
priceConfig.setRouteId("a3f256c1-0e43-4f7d-9c21-121bf258101f");
priceConfig.setTrainType(gaoTieOne);
priceConfig.setBasicPriceRate(0.7);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("7de18cf8-bb17-4bb2-aeb4-85d8176d3a93").toString());
priceConfig.setRouteId("084837bb-53c8-4438-87c8-0321a4d09917");
priceConfig.setTrainType("GaoTieTwo");
priceConfig.setBasicPriceRate(0.6);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("d5c4523a-827c-468c-95be-e9024a40572e").toString());
priceConfig.setRouteId("f3d4d4ef-693b-4456-8eed-59c0d717dd08");
priceConfig.setTrainType("DongCheOne");
priceConfig.setBasicPriceRate(0.45);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("b90a6ad7-ffad-4624-9655-48e9e185fa6c").toString());
priceConfig.setRouteId("0b23bd3e-876a-4af3-b920-c50a90c90b04");
priceConfig.setTrainType(zhiDa);
priceConfig.setBasicPriceRate(0.35);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("8fb01829-393f-4af4-9e96-f72866f94d14").toString());
priceConfig.setRouteId("9fc9c261-3263-4bfa-82f8-bb44e06b2f52");
priceConfig.setTrainType(zhiDa);
priceConfig.setBasicPriceRate(0.35);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("8b059dc5-01a2-4f8f-8f94-6c886b38bb34").toString());
priceConfig.setRouteId("d693a2c5-ef87-4a3c-bef8-600b43f62c68");
priceConfig.setTrainType(zhiDa);
priceConfig.setBasicPriceRate(0.32);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("dd0e572e-7443-420c-8280-7d8215636069").toString());
priceConfig.setRouteId("20eb7122-3a11-423f-b10a-be0dc5bce7db");
priceConfig.setTrainType("TeKuai");
priceConfig.setBasicPriceRate(0.30);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
priceConfig.setId(UUID.fromString("0eb474c9-f8be-4119-8681-eb538a404a6a").toString());
priceConfig.setRouteId("1367db1f-461e-4ab7-87ad-2bcc05fd9cb7");
priceConfig.setTrainType("KuaiSu");
priceConfig.setBasicPriceRate(0.2);
priceConfig.setFirstClassPriceRate(1.0);
service.createNewPriceConfig(priceConfig, null);
}
}
| 4,205 | 42.360825 | 94 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/repository/PriceConfigRepository.java
|
package price.repository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import price.entity.PriceConfig;
import java.util.List;
import java.util.Optional;
/**
* @author fdse
*/
@Repository
public interface PriceConfigRepository extends CrudRepository<PriceConfig, String> {
@Override
Optional<PriceConfig> findById(String id);
PriceConfig findByRouteIdAndTrainType(String routeId,String trainType);
@Query(value="SELECT * FROM price_config WHERE route_id IN ?1 AND train_type IN ?2", nativeQuery = true)
List<PriceConfig> findByRouteIdsAndTrainTypes(List<String> routeIds, List<String> trainTypes);
@Override
List<PriceConfig> findAll();
}
| 794 | 27.392857 | 108 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/service/PriceService.java
|
package price.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import price.entity.PriceConfig;
import java.util.List;
import java.util.Map;
/**
* @author fdse
*/
public interface PriceService {
Response createNewPriceConfig(PriceConfig priceConfig, HttpHeaders headers);
PriceConfig findById(String id, HttpHeaders headers);
Response findByRouteIdsAndTrainTypes(List<String> ridsAndTts, HttpHeaders headers);
Response findByRouteIdAndTrainType(String routeId, String trainType, HttpHeaders headers);
Response findAllPriceConfig(HttpHeaders headers);
Response deletePriceConfig(String pcId, HttpHeaders headers);
Response updatePriceConfig(PriceConfig c, HttpHeaders headers);
}
| 766 | 22.96875 | 94 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/main/java/price/service/PriceServiceImpl.java
|
package price.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 price.entity.PriceConfig;
import price.repository.PriceConfigRepository;
import java.util.*;
/**
* @author fdse
*/
@Service
public class PriceServiceImpl implements PriceService {
@Autowired(required=true)
private PriceConfigRepository priceConfigRepository;
private static final Logger LOGGER = LoggerFactory.getLogger(PriceServiceImpl.class);
String noThatConfig = "No that config";
@Override
public Response createNewPriceConfig(PriceConfig createAndModifyPriceConfig, HttpHeaders headers) {
PriceServiceImpl.LOGGER.info("[createNewPriceConfig]");
PriceConfig priceConfig = null;
// create
if (createAndModifyPriceConfig.getId() == null || createAndModifyPriceConfig.getId().toString().length() < 10) {
priceConfig = new PriceConfig();
priceConfig.setId(UUID.randomUUID().toString());
priceConfig.setBasicPriceRate(createAndModifyPriceConfig.getBasicPriceRate());
priceConfig.setFirstClassPriceRate(createAndModifyPriceConfig.getFirstClassPriceRate());
priceConfig.setRouteId(createAndModifyPriceConfig.getRouteId());
priceConfig.setTrainType(createAndModifyPriceConfig.getTrainType());
priceConfigRepository.save(priceConfig);
} else {
// modify
Optional<PriceConfig> op = priceConfigRepository.findById(createAndModifyPriceConfig.getId());
if (!op.isPresent()) {
priceConfig = new PriceConfig();
priceConfig.setId(createAndModifyPriceConfig.getId());
}else{
priceConfig = op.get();
}
priceConfig.setBasicPriceRate(createAndModifyPriceConfig.getBasicPriceRate());
priceConfig.setFirstClassPriceRate(createAndModifyPriceConfig.getFirstClassPriceRate());
priceConfig.setRouteId(createAndModifyPriceConfig.getRouteId());
priceConfig.setTrainType(createAndModifyPriceConfig.getTrainType());
priceConfigRepository.save(priceConfig);
}
return new Response<>(1, "Create success", priceConfig);
}
@Override
public PriceConfig findById(String id, HttpHeaders headers) {
PriceServiceImpl.LOGGER.info("[findById][ID: {}]", id);
Optional<PriceConfig> op = priceConfigRepository.findById(UUID.fromString(id).toString());
if(op.isPresent()){
return op.get();
}
return null;
}
@Override
public Response findByRouteIdAndTrainType(String routeId, String trainType, HttpHeaders headers) {
PriceServiceImpl.LOGGER.info("[findByRouteIdAndTrainType][Route: {} , Train Type: {}]", routeId, trainType);
PriceConfig priceConfig = priceConfigRepository.findByRouteIdAndTrainType(routeId, trainType);
//PriceServiceImpl.LOGGER.info("[findByRouteIdAndTrainType]");
if (priceConfig == null) {
PriceServiceImpl.LOGGER.warn("[findByRouteIdAndTrainType][Find by route and train type warn][PricrConfig not found][RouteId: {}, TrainType: {}]",routeId,trainType);
return new Response<>(0, noThatConfig, null);
} else {
return new Response<>(1, "Success", priceConfig);
}
}
@Override
public Response findByRouteIdsAndTrainTypes(List<String> ridsAndTts, HttpHeaders headers){
List<String> routeIds = new ArrayList<>();
List<String> trainTypes = new ArrayList<>();
for(String rts: ridsAndTts){
List<String> r_t = Arrays.asList(rts.split(":"));
routeIds.add(r_t.get(0));
trainTypes.add(r_t.get(1));
}
List<PriceConfig> pcs = priceConfigRepository.findByRouteIdsAndTrainTypes(routeIds, trainTypes);
Map<String, PriceConfig> pcMap = new HashMap<>();
for(PriceConfig pc: pcs){
String key = pc.getRouteId() + ":" + pc.getTrainType();
if(ridsAndTts.contains(key)){
pcMap.put(key, pc);
}
}
if (pcMap == null) {
PriceServiceImpl.LOGGER.warn("[findByRouteIdsAndTrainTypes][Find by routes and train types warn][PricrConfig not found][RouteIds: {}, TrainTypes: {}]",routeIds,trainTypes);
return new Response<>(0, noThatConfig, null);
} else {
return new Response<>(1, "Success", pcMap);
}
}
@Override
public Response findAllPriceConfig(HttpHeaders headers) {
List<PriceConfig> list = priceConfigRepository.findAll();
if (list == null) {
list = new ArrayList<>();
}
if (!list.isEmpty()) {
PriceServiceImpl.LOGGER.warn("[findAllPriceConfig][Find all price config warn][{}]","No Content");
return new Response<>(1, "Success", list);
} else {
return new Response<>(0, "No price config", null);
}
}
@Override
public Response deletePriceConfig(String pcId, HttpHeaders headers) {
Optional<PriceConfig> op = priceConfigRepository.findById(pcId);
if (!op.isPresent()) {
PriceServiceImpl.LOGGER.error("[deletePriceConfig][Delete price config error][Price config not found][PriceConfigId: {}]",pcId);
return new Response<>(0, noThatConfig, null);
} else {
PriceConfig pc = op.get();
priceConfigRepository.delete(pc);
return new Response<>(1, "Delete success", pc);
}
}
@Override
public Response updatePriceConfig(PriceConfig c, HttpHeaders headers) {
Optional<PriceConfig> op = priceConfigRepository.findById(c.getId());
if (!op.isPresent()) {
PriceServiceImpl.LOGGER.error("[updatePriceConfig][Update price config error][Price config not found][PriceConfigId: {}]",c.getId());
return new Response<>(0, noThatConfig, null);
} else {
PriceConfig priceConfig = op.get();
priceConfig.setId(c.getId());
priceConfig.setBasicPriceRate(c.getBasicPriceRate());
priceConfig.setFirstClassPriceRate(c.getFirstClassPriceRate());
priceConfig.setRouteId(c.getRouteId());
priceConfig.setTrainType(c.getTrainType());
priceConfigRepository.save(priceConfig);
return new Response<>(1, "Update success", priceConfig);
}
}
}
| 6,649 | 41.628205 | 184 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/test/java/price/controller/PriceControllerTest.java
|
package price.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 price.entity.PriceConfig;
import price.service.PriceService;
@RunWith(JUnit4.class)
public class PriceControllerTest {
@InjectMocks
private PriceController priceController;
@Mock
private PriceService service;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(priceController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/priceservice/prices/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Price Service ] !"));
}
@Test
public void testQuery() throws Exception {
Mockito.when(service.findByRouteIdAndTrainType(Mockito.anyString(), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/priceservice/prices/route_id/train_type"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryAll() throws Exception {
Mockito.when(service.findAllPriceConfig(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/priceservice/prices"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreate() throws Exception {
PriceConfig info = new PriceConfig();
Mockito.when(service.createNewPriceConfig(Mockito.any(PriceConfig.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/priceservice/prices").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isCreated())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDelete() throws Exception {
PriceConfig info = new PriceConfig();
Mockito.when(service.deletePriceConfig(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/priceservice/prices").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 {
PriceConfig info = new PriceConfig();
Mockito.when(service.updatePriceConfig(Mockito.any(PriceConfig.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/priceservice/prices").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 4,566 | 45.602041 | 162 |
java
|
train-ticket
|
train-ticket-master/ts-price-service/src/test/java/price/service/PriceServiceImplTest.java
|
package price.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.http.HttpHeaders;
import price.entity.PriceConfig;
import price.repository.PriceConfigRepository;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@RunWith(JUnit4.class)
public class PriceServiceImplTest {
@InjectMocks
private PriceServiceImpl priceServiceImpl;
@Mock
private PriceConfigRepository priceConfigRepository;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testCreateNewPriceConfig1() {
PriceConfig createAndModifyPriceConfig = new PriceConfig();
Mockito.when(priceConfigRepository.save(Mockito.any(PriceConfig.class))).thenReturn(null);
Response result = priceServiceImpl.createNewPriceConfig(createAndModifyPriceConfig, headers);
Assert.assertNotNull(result.getData());
}
@Test
public void testCreateNewPriceConfig2() {
PriceConfig createAndModifyPriceConfig = new PriceConfig(UUID.randomUUID().toString(), "G", "G1255", 1.0, 2.0);
Mockito.when(priceConfigRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(null);
Mockito.when(priceConfigRepository.save(Mockito.any(PriceConfig.class))).thenReturn(null);
Response result = priceServiceImpl.createNewPriceConfig(createAndModifyPriceConfig, headers);
Assert.assertEquals(new Response<>(1, "Create success", createAndModifyPriceConfig), result);
}
@Test
public void testFindById() {
Mockito.when(priceConfigRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(null);
PriceConfig result = priceServiceImpl.findById(UUID.randomUUID().toString(), headers);
Assert.assertNull(result);
}
@Test
public void testFindByRouteIdAndTrainType1() {
Mockito.when(priceConfigRepository.findByRouteIdAndTrainType(Mockito.anyString(), Mockito.anyString())).thenReturn(null);
Response result = priceServiceImpl.findByRouteIdAndTrainType("route_id", "train_type", headers);
Assert.assertEquals(new Response<>(0, "No that config", null), result);
}
@Test
public void testFindByRouteIdAndTrainType2() {
PriceConfig priceConfig = new PriceConfig();
Mockito.when(priceConfigRepository.findByRouteIdAndTrainType(Mockito.anyString(), Mockito.anyString())).thenReturn(priceConfig);
Response result = priceServiceImpl.findByRouteIdAndTrainType("route_id", "train_type", headers);
Assert.assertEquals(new Response<>(1, "Success", priceConfig), result);
}
@Test
public void testFindAllPriceConfig1() {
Mockito.when(priceConfigRepository.findAll()).thenReturn(null);
Response result = priceServiceImpl.findAllPriceConfig(headers);
Assert.assertEquals(new Response<>(0, "No price config", null), result);
}
@Test
public void testFindAllPriceConfig2() {
List<PriceConfig> list = new ArrayList<>();
list.add(new PriceConfig());
Mockito.when(priceConfigRepository.findAll()).thenReturn(list);
Response result = priceServiceImpl.findAllPriceConfig(headers);
Assert.assertEquals(new Response<>(1, "Success", list), result);
}
@Test
public void testDeletePriceConfig1() {
PriceConfig c = new PriceConfig();
Mockito.when(priceConfigRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(null);
Response result = priceServiceImpl.deletePriceConfig(c.getId(), headers);
Assert.assertEquals(new Response<>(0, "No that config", null), result);
}
@Test
public void testDeletePriceConfig2() {
PriceConfig c = new PriceConfig();
Mockito.when(priceConfigRepository.findById(Mockito.any(UUID.class).toString()).get()).thenReturn(c);
Mockito.doNothing().doThrow(new RuntimeException()).when(priceConfigRepository).delete(Mockito.any(PriceConfig.class));
Response result = priceServiceImpl.deletePriceConfig(c.getId(), headers);
Assert.assertEquals(new Response<>(1, "Delete success", c), result);
}
@Test
public void testUpdatePriceConfig1() {
PriceConfig c = new PriceConfig();
Mockito.when(priceConfigRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(null);
Response result = priceServiceImpl.updatePriceConfig(c, headers);
Assert.assertEquals(new Response<>(0, "No that config", null), result);
}
@Test
public void testUpdatePriceConfig2() {
PriceConfig c = new PriceConfig();
Mockito.when(priceConfigRepository.findById(Mockito.any(UUID.class).toString()).get()).thenReturn(c);
Mockito.when(priceConfigRepository.save(Mockito.any(PriceConfig.class))).thenReturn(null);
Response result = priceServiceImpl.updatePriceConfig(c, headers);
Assert.assertEquals(new Response<>(1, "Update success", c), result);
}
}
| 5,303 | 40.76378 | 136 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/main/java/rebook/RebookApplication.java
|
package rebook;
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 RebookApplication {
public static void main(String[] args) {
SpringApplication.run(RebookApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,180 | 31.805556 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/main/java/rebook/config/SecurityConfig.java
|
package rebook.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/rebookservice/**").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,248 | 38.621951 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/main/java/rebook/controller/RebookController.java
|
package rebook.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 rebook.entity.RebookInfo;
import rebook.service.RebookService;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/rebookservice")
public class RebookController {
@Autowired
RebookService service;
private static final Logger LOGGER = LoggerFactory.getLogger(RebookController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ Rebook Service ] !";
}
@PostMapping(value = "/rebook/difference")
public HttpEntity payDifference(@RequestBody RebookInfo info,
@RequestHeader HttpHeaders headers) {
RebookController.LOGGER.info("[payDifference][Pay difference][OrderId: {}]",info.getOrderId());
return ok(service.payDifference(info, headers));
}
@PostMapping(value = "/rebook")
public HttpEntity rebook(@RequestBody RebookInfo info, @RequestHeader HttpHeaders headers) {
RebookController.LOGGER.info("[rebook][Rebook][OrderId: {}, Old Trip Id: {}, New Trip Id: {}, Date: {}, Seat Type: {}]", info.getOrderId(), info.getOldTripId(), info.getTripId(), info.getDate(), info.getSeatType());
return ok(service.rebook(info, headers));
}
}
| 1,555 | 33.577778 | 223 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/main/java/rebook/entity/RebookInfo.java
|
package rebook.entity;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* @author fdse
*/
@Data
public class RebookInfo {
@Valid
@NotNull
private String loginId;
@Valid
@NotNull
private String orderId;
@Valid
@NotNull
private String oldTripId;
@Valid
@NotNull
private String tripId;
@Valid
@NotNull
private int seatType;
@Valid
@NotNull
private String date;
public RebookInfo(){
//Default Constructor
this.loginId = "";
this.orderId = "";
this.oldTripId = "";
this.tripId = "";
this.seatType = 0;
this.date = StringUtils.Date2String(new Date());
}
}
| 815 | 15 | 56 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/main/java/rebook/service/RebookService.java
|
package rebook.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import rebook.entity.RebookInfo;
/**
* @author fdse
*/
public interface RebookService {
Response rebook(RebookInfo info, HttpHeaders headers);
Response payDifference(RebookInfo info, HttpHeaders headers);
}
| 328 | 22.5 | 66 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/main/java/rebook/service/RebookServiceImpl.java
|
package rebook.service;
import edu.fudan.common.entity.Trip;
import edu.fudan.common.entity.TripAllDetail;
import edu.fudan.common.entity.TripAllDetailInfo;
import edu.fudan.common.entity.TripResponse;
import edu.fudan.common.util.JsonUtils;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import org.apache.tomcat.jni.Time;
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 edu.fudan.common.entity.*;
import rebook.entity.*;
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
/**
* @author fdse
*/
@Service
public class RebookServiceImpl implements RebookService {
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(RebookServiceImpl.class);
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
@Override
public Response rebook(RebookInfo info, HttpHeaders httpHeaders) {
Response<Order> queryOrderResult = getOrderByRebookInfo(info, httpHeaders);
if (queryOrderResult.getStatus() == 1) {
if (queryOrderResult.getData().getStatus() != 1) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Order not suitable to rebook][OrderId: {}]",info.getOrderId());
return new Response<>(0, "you order not suitable to rebook!", null);
}
} else {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Order not found][OrderId: {}]",info.getOrderId());
return new Response(0, "order not found", null);
}
Order order = queryOrderResult.getData();
int status = order.getStatus();
if (status == OrderStatus.NOTPAID.getCode()) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Order not paid][OrderId: {}]",info.getOrderId());
return new Response<>(0, "You haven't paid the original ticket!", null);
} else if (status == OrderStatus.PAID.getCode()) {
// do nothing
} else if (status == OrderStatus.CHANGE.getCode()) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Order can't change twice][OrderId: {}]",info.getOrderId());
return new Response<>(0, "You have already changed your ticket and you can only change one time.", null);
} else if (status == OrderStatus.COLLECTED.getCode()) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Order already collected][OrderId: {}]",info.getOrderId());
return new Response<>(0, "You have already collected your ticket and you can change it now.", null);
} else {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Order can't change][OrderId: {}]",info.getOrderId());
return new Response<>(0, "You can't change your ticket.", null);
}
//Check the current time and the bus time of the old order, and judge whether the ticket can be changed according to the time. The ticket cannot be changed after two hours.
if (!checkTime(order.getTravelDate(), order.getTravelTime())) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Order beyond change time][OrderId: {}]",info.getOrderId());
return new Response<>(0, "You can only change the ticket before the train start or within 2 hours after the train start.", null);
}
//The departure and destination cannot be changed, only the train number, seat and time can be changed
//Check the info of seat availability and trains
TripAllDetailInfo gtdi = new TripAllDetailInfo();
gtdi.setFrom(order.getFrom());
gtdi.setTo(order.getTo());
gtdi.setTravelDate(info.getDate());
gtdi.setTripId(info.getTripId());
Response<TripAllDetail> gtdr = getTripAllDetailInformation(gtdi, info.getTripId(), httpHeaders);
if (gtdr.getStatus() == 0) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Trip detail not found][OrderId: {}]",info.getOrderId());
return new Response<>(0, gtdr.getMsg(), null);
} else {
TripResponse tripResponse = gtdr.getData().getTripResponse();
if (info.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {
if (tripResponse.getConfortClass() <= 0) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Seat Not Enough][OrderId: {},SeatType: {}]",info.getOrderId(),info.getSeatType());
return new Response<>(0, "Seat Not Enough", null);
}
} else {
if (tripResponse.getEconomyClass() == SeatClass.SECONDCLASS.getCode() && tripResponse.getConfortClass() <= 0) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Seat Not Enough][OrderId: {},SeatType: {}]",info.getOrderId(),info.getSeatType());
return new Response<>(0, "Seat Not Enough", null);
}
}
}
//Deal with the difference, more refund less compensation
//Return the original ticket so that someone else can book the corresponding seat
String ticketPrice = "0";
if (info.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {
ticketPrice = ((TripAllDetail) gtdr.getData()).getTripResponse().getPriceForConfortClass();
} else if (info.getSeatType() == SeatClass.SECONDCLASS.getCode()) {
ticketPrice = ((TripAllDetail) gtdr.getData()).getTripResponse().getPriceForEconomyClass();
}
String oldPrice = order.getPrice();
BigDecimal priceOld = new BigDecimal(oldPrice);
BigDecimal priceNew = new BigDecimal(ticketPrice);
if (priceOld.compareTo(priceNew) > 0) {
//Refund the difference
String difference = priceOld.subtract(priceNew).toString();
if (!drawBackMoney(info.getLoginId(), difference, httpHeaders)) {
RebookServiceImpl.LOGGER.warn("[rebook][Rebook warn][Can't draw back the difference money][OrderId: {},LoginId: {},difference: {}]",info.getOrderId(),info.getLoginId(),difference);
return new Response<>(0, "Can't draw back the difference money, please try again!", null);
}
return updateOrder(order, info, (TripAllDetail) gtdr.getData(), ticketPrice, httpHeaders);
} else if (priceOld.compareTo(priceNew) == 0) {
//do nothing
return updateOrder(order, info, (TripAllDetail) gtdr.getData(), ticketPrice, httpHeaders);
} else {
//make up the difference
String difference = priceNew.subtract(priceOld).toString();
Order orderMoneyDifference = new Order();
orderMoneyDifference.setDifferenceMoney(difference);
return new Response<>(2, "Please pay the different money!", orderMoneyDifference);
}
}
@Override
public Response payDifference(RebookInfo info, HttpHeaders httpHeaders) {
Response queryOrderResult = getOrderByRebookInfo(info, httpHeaders);
if (queryOrderResult.getStatus() == 0) {
return new Response<>(0, queryOrderResult.getMsg(), null);
}
Order order = (Order) queryOrderResult.getData();
TripAllDetailInfo gtdi = new TripAllDetailInfo();
gtdi.setFrom(order.getFrom());
gtdi.setTo(order.getTo());
gtdi.setTravelDate(info.getDate());
gtdi.setTripId(info.getTripId());
// TripAllDetail
Response gtdrResposne = getTripAllDetailInformation(gtdi, info.getTripId(), httpHeaders);
TripAllDetail gtdr = (TripAllDetail) gtdrResposne.getData();
String ticketPrice = "0";
if (info.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {
ticketPrice = gtdr.getTripResponse().getPriceForConfortClass();
} else if (info.getSeatType() == SeatClass.SECONDCLASS.getCode()) {
ticketPrice = gtdr.getTripResponse().getPriceForEconomyClass();
}
String oldPrice = order.getPrice();
BigDecimal priceOld = new BigDecimal(oldPrice);
BigDecimal priceNew = new BigDecimal(ticketPrice);
if (payDifferentMoney(info.getOrderId(), info.getTripId(), info.getLoginId(), priceNew.subtract(priceOld).toString(), httpHeaders)) {
return updateOrder(order, info, gtdr, ticketPrice, httpHeaders);
} else {
RebookServiceImpl.LOGGER.warn("[payDifference][Pay difference warn][Can't pay the difference money][OrderId: {},LoginId: {},TripId: {}]",info.getOrderId(),info.getLoginId(),info.getTripId());
return new Response<>(0, "Can't pay the difference,please try again", null);
}
}
private Response updateOrder(Order order, RebookInfo info, TripAllDetail gtdr, String ticketPrice, HttpHeaders httpHeaders) {
//4.Modify the original order and set the information of the order
Trip trip = gtdr.getTrip();
String oldTripId = order.getTrainNumber();
order.setTrainNumber(info.getTripId());
order.setBoughtDate(StringUtils.Date2String(new Date()));
order.setStatus(OrderStatus.CHANGE.getCode());
order.setPrice(ticketPrice);//Set ticket price
order.setSeatClass(info.getSeatType());
order.setTravelDate(info.getDate());
order.setTravelTime(trip.getStartTime());
Route route = getRouteByRouteId(trip.getRouteId(), httpHeaders);
TrainType trainType = queryTrainTypeByName(trip.getTrainTypeName(), httpHeaders);
List<String> stations = route.getStations();
int firstClassTotalNum = trainType.getConfortClass();
int secondClassTotalNum = trainType.getEconomyClass();
if (info.getSeatType() == SeatClass.FIRSTCLASS.getCode()) {//Dispatch the seat
Ticket ticket =
dipatchSeat(info.getDate(),
order.getTrainNumber(), order.getFrom(), order.getTo(),
SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, stations, httpHeaders);
order.setSeatClass(SeatClass.FIRSTCLASS.getCode());
order.setSeatNumber("" + ticket.getSeatNo());
} else {
Ticket ticket =
dipatchSeat(info.getDate(),
order.getTrainNumber(), order.getFrom(), order.getTo(),
SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, stations, httpHeaders);
order.setSeatClass(SeatClass.SECONDCLASS.getCode());
order.setSeatNumber("" + ticket.getSeatNo());
}
//Update order information
//If the original order and the new order are located in the high-speed train and other orders respectively, the original order should be deleted and created on the other side with a new id.
if ((tripGD(oldTripId) && tripGD(info.getTripId())) || (!tripGD(oldTripId) && !tripGD(info.getTripId()))) {
Response changeOrderResult = updateOrder(order, info.getTripId(), httpHeaders);
if (changeOrderResult.getStatus() == 1) {
return new Response<>(1, "Success!", order);
} else {
RebookServiceImpl.LOGGER.error("[updateOrder][Update order error][OrderId: {},TripId: {}]",info.getOrderId(),info.getTripId());
return new Response<>(0, "Can't update Order!", null);
}
} else {
//Delete the original order
deleteOrder(order.getId().toString(), oldTripId, httpHeaders);
//Create a new order on the other side
createOrder(order, order.getTrainNumber(), httpHeaders);
return new Response<>(1, "Success", order);
}
}
public Ticket dipatchSeat(String date, String tripId, String startStationId, String endStataionId, int seatType, int tatalNum, List<String> stations, HttpHeaders httpHeaders) {
Seat seatRequest = new Seat();
seatRequest.setTravelDate(date);
seatRequest.setTrainNumber(tripId);
seatRequest.setSeatType(seatType);
seatRequest.setStartStation(startStationId);
seatRequest.setDestStation(endStataionId);
seatRequest.setTotalNum(tatalNum);
seatRequest.setStations(stations);
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestEntityTicket = new HttpEntity(seatRequest, newHeaders);
String seat_service_url = getServiceUrl("ts-seat-service");
ResponseEntity<Response<Ticket>> reTicket = restTemplate.exchange(
seat_service_url + "/api/v1/seatservice/seats",
HttpMethod.POST,
requestEntityTicket,
new ParameterizedTypeReference<Response<Ticket>>() {
});
return reTicket.getBody().getData();
}
private boolean tripGD(String tripId) {
return tripId.startsWith("G") || tripId.startsWith("D");
}
private boolean checkTime(String travelDate, String travelTime) {
boolean result = true;
Calendar calDateA = Calendar.getInstance();
Date today = new Date();
calDateA.setTime(today);
Calendar calDateB = Calendar.getInstance();
calDateB.setTime(StringUtils.String2Date(travelDate));
Calendar calDateC = Calendar.getInstance();
calDateC.setTime(StringUtils.String2Date(travelTime));
if (calDateA.get(Calendar.YEAR) > calDateB.get(Calendar.YEAR)) {
result = false;
} else if (calDateA.get(Calendar.YEAR) == calDateB.get(Calendar.YEAR)) {
if (calDateA.get(Calendar.MONTH) > calDateB.get(Calendar.MONTH)) {
result = false;
} else if (calDateA.get(Calendar.MONTH) == calDateB.get(Calendar.MONTH)) {
if (calDateA.get(Calendar.DAY_OF_MONTH) > calDateB.get(Calendar.DAY_OF_MONTH)) {
result = false;
} else if (calDateA.get(Calendar.DAY_OF_MONTH) == calDateB.get(Calendar.DAY_OF_MONTH)) {
if (calDateA.get(Calendar.HOUR_OF_DAY) > calDateC.get(Calendar.HOUR_OF_DAY) + 2) {
result = false;
} else if (calDateA.get(Calendar.HOUR_OF_DAY) == (calDateC.get(Calendar.HOUR_OF_DAY) + 2) && calDateA.get(Calendar.MINUTE) > calDateC.get(Calendar.MINUTE)) {
result = false;
}
}
}
}
return result;
}
private Response<TripAllDetail> getTripAllDetailInformation(TripAllDetailInfo gtdi, String tripId, HttpHeaders httpHeaders) {
Response<TripAllDetail> gtdr;
String requestUrl = "";
String travel_service_url = getServiceUrl("ts-travel-service");
String travel2_service_url = getServiceUrl("ts-travel2-service");
if (tripId.startsWith("G") || tripId.startsWith("D")) {
requestUrl = travel_service_url + "/api/v1/travelservice/trip_detail";
// ts-travel-service:12346/travel/getTripAllDetailInfo
} else {
requestUrl = travel2_service_url + "/api/v1/travel2service/trip_detail";
//ts-travel2-service:16346/travel2/getTripAllDetailInfo
}
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestGetTripAllDetailResult = new HttpEntity(gtdi, newHeaders);
ResponseEntity<Response<TripAllDetail>> reGetTripAllDetailResult = restTemplate.exchange(
requestUrl,
HttpMethod.POST,
requestGetTripAllDetailResult,
new ParameterizedTypeReference<Response<TripAllDetail>>() {
});
gtdr = reGetTripAllDetailResult.getBody();
return gtdr;
}
private Response createOrder(Order order, String tripId, HttpHeaders httpHeaders) {
String requestUrl = "";
String order_service_url = getServiceUrl("ts-order-service");
String order_other_service_url = getServiceUrl("ts-order-other-service");
if (tripId.startsWith("G") || tripId.startsWith("D")) {
// ts-order-service:12031/order/create
requestUrl = order_service_url + "/api/v1/orderservice/order";
} else {
//ts-order-other-service:12032/orderOther/create
requestUrl = order_other_service_url + "/api/v1/orderOtherService/orderOther";
}
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestCreateOrder = new HttpEntity(order, newHeaders);
ResponseEntity<Response> reCreateOrder = restTemplate.exchange(
requestUrl,
HttpMethod.POST,
requestCreateOrder,
Response.class);
return reCreateOrder.getBody();
}
private Response updateOrder(Order info, String tripId, HttpHeaders httpHeaders) {
String requestOrderUtl = "";
String order_service_url = getServiceUrl("ts-order-service");
String order_other_service_url = getServiceUrl("ts-order-other-service");
if (tripGD(tripId)) {
requestOrderUtl = order_service_url + "/api/v1/orderservice/order";
} else {
requestOrderUtl = order_other_service_url + "/api/v1/orderOtherService/orderOther";
}
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestUpdateOrder = new HttpEntity(info, newHeaders);
ResponseEntity<Response> reUpdateOrder = restTemplate.exchange(
requestOrderUtl,
HttpMethod.PUT,
requestUpdateOrder,
Response.class);
return reUpdateOrder.getBody();
}
private Response deleteOrder(String orderId, String tripId, HttpHeaders httpHeaders) {
String requestUrl = "";
String order_service_url = getServiceUrl("ts-order-service");
String order_other_service_url = getServiceUrl("ts-order-other-service");
if (tripGD(tripId)) {
requestUrl = order_service_url + "/api/v1/orderservice/order/" + orderId;
} else {
requestUrl = order_other_service_url + "/api/v1/orderOtherService/orderOther/" + orderId;
}
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestDeleteOrder = new HttpEntity(newHeaders);
ResponseEntity<Response> reDeleteOrder = restTemplate.exchange(
requestUrl,
HttpMethod.POST,
requestDeleteOrder,
Response.class);
return reDeleteOrder.getBody();
}
private Response<Order> getOrderByRebookInfo(RebookInfo info, HttpHeaders httpHeaders) {
Response<Order> queryOrderResult;
//Change can only be changed once, check the status of the order to determine whether it has been changed
String requestUrl = "";
String order_service_url = getServiceUrl("ts-order-service");
String order_other_service_url = getServiceUrl("ts-order-other-service");
if (info.getOldTripId().startsWith("G") || info.getOldTripId().startsWith("D")) {
requestUrl = order_service_url + "/api/v1/orderservice/order/" + info.getOrderId();
} else {
requestUrl = order_other_service_url + "/api/v1/orderOtherService/orderOther/" + info.getOrderId();
}
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestEntityGetOrderByRebookInfo = new HttpEntity(newHeaders);
ResponseEntity<Response<Order>> reGetOrderByRebookInfo = restTemplate.exchange(
requestUrl,
HttpMethod.GET,
requestEntityGetOrderByRebookInfo,
new ParameterizedTypeReference<Response<Order>>() {
});
queryOrderResult = reGetOrderByRebookInfo.getBody();
return queryOrderResult;
}
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);
}
private Route getRouteByRouteId(String routeId, HttpHeaders headers) {
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) {
LOGGER.warn("[getRouteByRouteId][Get Route By Id Failed][Fail msg: {}]", result.getMsg());
return null;
} else {
LOGGER.info("[getRouteByRouteId][Get Route By Id][Success]");
return JsonUtils.conveterObject(result.getData(), Route.class);
}
}
private boolean payDifferentMoney(String orderId, String tripId, String userId, String money, HttpHeaders httpHeaders) {
PaymentDifferenceInfo info = new PaymentDifferenceInfo();
info.setOrderId(orderId);
info.setTripId(tripId);
info.setUserId(userId);
info.setPrice(money);
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestEntityPayDifferentMoney = new HttpEntity(info, newHeaders);
String inside_payment_service_url = getServiceUrl("ts-inside-payment-service");
ResponseEntity<Response> rePayDifferentMoney = restTemplate.exchange(
inside_payment_service_url + "/api/v1/inside_pay_service/inside_payment/difference",
HttpMethod.POST,
requestEntityPayDifferentMoney,
Response.class);
Response result = rePayDifferentMoney.getBody();
return result.getStatus() == 1;
}
private boolean drawBackMoney(String userId, String money, HttpHeaders httpHeaders) {
HttpHeaders newHeaders = getAuthorizationHeadersFrom(httpHeaders);
HttpEntity requestEntityDrawBackMoney = new HttpEntity(newHeaders);
String inside_payment_service_url = getServiceUrl("ts-inside-payment-service");
ResponseEntity<Response> reDrawBackMoney = restTemplate.exchange(
inside_payment_service_url + "/api/v1/inside_pay_service/inside_payment/drawback/" + userId + "/" + money,
HttpMethod.GET,
requestEntityDrawBackMoney,
Response.class);
Response result = reDrawBackMoney.getBody();
return result.getStatus() == 1;
}
public static HttpHeaders getAuthorizationHeadersFrom(HttpHeaders oldHeaders) {
HttpHeaders newHeaders = new HttpHeaders();
if (oldHeaders.containsKey(HttpHeaders.AUTHORIZATION)) {
newHeaders.add(HttpHeaders.AUTHORIZATION, oldHeaders.getFirst(HttpHeaders.AUTHORIZATION));
}
return newHeaders;
}
}
| 23,979 | 49.378151 | 203 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/test/java/rebook/controller/RebookControllerTest.java
|
package rebook.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 rebook.entity.RebookInfo;
import rebook.service.RebookService;
@RunWith(JUnit4.class)
public class RebookControllerTest {
@InjectMocks
private RebookController rebookController;
@Mock
private RebookService service;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(rebookController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/rebookservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Rebook Service ] !"));
}
@Test
public void testPayDifference() throws Exception {
RebookInfo info = new RebookInfo();
Mockito.when(service.payDifference(Mockito.any(RebookInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/rebookservice/rebook/difference").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testRebook() throws Exception {
RebookInfo info = new RebookInfo();
Mockito.when(service.rebook(Mockito.any(RebookInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/rebookservice/rebook").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 2,846 | 40.26087 | 172 |
java
|
train-ticket
|
train-ticket-master/ts-rebook-service/src/test/java/rebook/service/RebookServiceImplTest.java
|
package rebook.service;
import edu.fudan.common.entity.Seat;
import edu.fudan.common.entity.Ticket;
import edu.fudan.common.entity.TripAllDetail;
import edu.fudan.common.entity.TripResponse;
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 edu.fudan.common.entity.*;
import rebook.entity.RebookInfo;
import java.util.Date;
@RunWith(JUnit4.class)
public class RebookServiceImplTest {
@InjectMocks
private RebookServiceImpl rebookServiceImpl;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testRebook() {
RebookInfo info = new RebookInfo();
info.setOldTripId("G");
info.setSeatType(2);
//response for getOrderByRebookInfo()
Order order = new Order();
order.setStatus(1);
order.setFrom("from_station");
order.setTo("to_station");
order.setPrice("1.0");
String date = StringUtils.Date2String(new Date());
order.setTravelDate(date);
order.setTravelTime(date);
Response<Order> response = new Response<>(1, null, order);
ResponseEntity<Response<Order>> re = new ResponseEntity<>(response, HttpStatus.OK);
//response for getTripAllDetailInformation()
TripAllDetail tripAllDetail = new TripAllDetail();
TripResponse tripResponse = new TripResponse();
tripResponse.setConfortClass(1);
tripResponse.setPriceForConfortClass("2.0");
tripAllDetail.setTripResponse(tripResponse);
Response<TripAllDetail> response2 = new Response<>(1, null, tripAllDetail);
ResponseEntity<Response<TripAllDetail>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re).thenReturn(re2);
//mock queryForStationName()
Response<String> response3 = new Response(null, null, "");
ResponseEntity<Response<String>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re3);
Response result = rebookServiceImpl.rebook(info, headers);
Assert.assertEquals("Please pay the different money!", result.getMsg());
}
@Test
public void testPayDifference() {
RebookInfo info = new RebookInfo();
info.setTripId("G");
info.setOldTripId("G");
info.setLoginId("login_id");
info.setDate("");
info.setSeatType(0);
//mock getOrderByRebookInfo() and getTripAllDetailInformation()
Order order = new Order();
order.setFrom("from_station");
order.setTo("to_station");
order.setPrice("0");
Response<Order> response = new Response<>(1, null, order);
ResponseEntity<Response<Order>> re = new ResponseEntity<>(response, HttpStatus.OK);
TripAllDetail tripAllDetail = new TripAllDetail();
Response<TripAllDetail> response2 = new Response<>(0, null, tripAllDetail);
ResponseEntity<Response<TripAllDetail>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re).thenReturn(re2);
//mock queryForStationName() and updateOrder()
Response response3 = new Response<>(0, null, "");
ResponseEntity<Response> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re3);
Response result = rebookServiceImpl.payDifference(info, headers);
Assert.assertEquals(new Response<>(0, "Can't pay the difference,please try again", null), result);
}
@Test
public void testDipatchSeat() {
Seat seatRequest = new Seat(StringUtils.Date2String(new Date()), "G1234", "start_station", "dest_station", 2, 100, null);
HttpEntity requestEntityTicket = new HttpEntity<>(seatRequest, headers);
Response<Ticket> response = new Response<>();
ResponseEntity<Response<Ticket>> reTicket = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
"http://ts-seat-service:18898/api/v1/seatservice/seats",
HttpMethod.POST,
requestEntityTicket,
new ParameterizedTypeReference<Response<Ticket>>() {
})).thenReturn(reTicket);
Ticket result = rebookServiceImpl.dipatchSeat(StringUtils.Date2String(new Date()), "G1234", "start_station", "dest_station", 2, 100, null,headers);
Assert.assertNull(result);
}
}
| 5,842 | 38.748299 | 155 |
java
|
train-ticket
|
train-ticket-master/ts-route-plan-service/src/main/java/plan/RoutePlanApplication.java
|
package plan;
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 RoutePlanApplication {
public static void main(String[] args) {
SpringApplication.run(RoutePlanApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,184 | 31.916667 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-route-plan-service/src/main/java/plan/config/SecurityConfig.java
|
package plan.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/routeplanservice/**").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,233 | 38.439024 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-route-plan-service/src/main/java/plan/controller/RoutePlanController.java
|
package plan.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.RoutePlanInfo;
import plan.service.RoutePlanService;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/routeplanservice")
public class RoutePlanController {
@Autowired
private RoutePlanService routePlanService;
private static final Logger LOGGER = LoggerFactory.getLogger(RoutePlanController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ RoutePlan Service ] !";
}
@PostMapping(value = "/routePlan/cheapestRoute")
public HttpEntity getCheapestRoutes(@RequestBody RoutePlanInfo info, @RequestHeader HttpHeaders headers) {
RoutePlanController.LOGGER.info("[searchCheapestResult][Get Cheapest Routes][From: {}, To: {}, Num: {}, Date: {}]", info.getStartStation(), info.getEndStation(), + info.getNum(), info.getTravelDate());
return ok(routePlanService.searchCheapestResult(info, headers));
}
@PostMapping(value = "/routePlan/quickestRoute")
public HttpEntity getQuickestRoutes(@RequestBody RoutePlanInfo info, @RequestHeader HttpHeaders headers) {
RoutePlanController.LOGGER.info("[searchQuickestResult][Get Quickest Routes][From: {}, To: {}, Num: {}, Date: {}]", info.getStartStation(), info.getEndStation(), info.getNum(), info.getTravelDate());
return ok(routePlanService.searchQuickestResult(info, headers));
}
@PostMapping(value = "/routePlan/minStopStations")
public HttpEntity getMinStopStations(@RequestBody RoutePlanInfo info, @RequestHeader HttpHeaders headers) {
RoutePlanController.LOGGER.info("[searchMinStopStations][Get Min Stop Stations][From: {}, To: {}, Num: {}, Date: {}]", info.getStartStation(), info.getEndStation(), info.getNum(), info.getTravelDate());
return ok(routePlanService.searchMinStopStations(info, headers));
}
}
| 2,194 | 43.795918 | 210 |
java
|
train-ticket
|
train-ticket-master/ts-route-plan-service/src/main/java/plan/service/RoutePlanService.java
|
package plan.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import edu.fudan.common.entity.RoutePlanInfo;
/**
* @author fdse
*/
public interface RoutePlanService {
/**
* search the cheapest result with route plan info
*
* @param info route plan info
* @param headers headers
* @return Response
*/
Response searchCheapestResult(RoutePlanInfo info, HttpHeaders headers);
/**
* search the quickest result with route plan info
*
* @param info route plan info
* @param headers headers
* @return Response
*/
Response searchQuickestResult(RoutePlanInfo info, HttpHeaders headers);
/**
* search min stop-station with route plan info
*
* @param info route plan info
* @param headers headers
* @return Response
*/
Response searchMinStopStations(RoutePlanInfo info, HttpHeaders headers);
}
| 947 | 22.7 | 76 |
java
|
train-ticket
|
train-ticket-master/ts-route-plan-service/src/main/java/plan/service/RoutePlanServiceImpl.java
|
package plan.service;
import edu.fudan.common.entity.*;
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 java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* @author fdse
*/
@Service
public class RoutePlanServiceImpl implements RoutePlanService {
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(RoutePlanServiceImpl.class);
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
@Override
public Response searchCheapestResult(RoutePlanInfo info, HttpHeaders headers) {
//1.Violence pulls out all the results of travel-service and travle2-service
TripInfo queryInfo = new TripInfo();
queryInfo.setStartPlace(info.getStartStation());
queryInfo.setEndPlace(info.getEndStation());
queryInfo.setDepartureTime(info.getTravelDate());
ArrayList<TripResponse> highSpeed = getTripFromHighSpeedTravelServive(queryInfo, headers);
ArrayList<TripResponse> normalTrain = getTripFromNormalTrainTravelService(queryInfo, headers);
//2.Sort by second-class seats
ArrayList<TripResponse> finalResult = new ArrayList<>();
finalResult.addAll(highSpeed);
finalResult.addAll(normalTrain);
float minPrice;
int minIndex = -1;
int size = Math.min(5, finalResult.size());
ArrayList<TripResponse> returnResult = new ArrayList<>();
for (int i = 0; i < size; i++) {
minPrice = Float.MAX_VALUE;
for (int j = 0; j < finalResult.size(); j++) {
TripResponse thisRes = finalResult.get(j);
if (Float.parseFloat(thisRes.getPriceForEconomyClass()) < minPrice) {
minPrice = Float.parseFloat(finalResult.get(j).getPriceForEconomyClass());
minIndex = j;
}
}
returnResult.add(finalResult.get(minIndex));
finalResult.remove(minIndex);
}
ArrayList<RoutePlanResultUnit> units = new ArrayList<>();
for (int i = 0; i < returnResult.size(); i++) {
TripResponse tempResponse = returnResult.get(i);
RoutePlanResultUnit tempUnit = new RoutePlanResultUnit();
tempUnit.setTripId(tempResponse.getTripId().toString());
tempUnit.setTrainTypeName(tempResponse.getTrainTypeName());
tempUnit.setStartStation(tempResponse.getStartStation());
tempUnit.setEndStation(tempResponse.getTerminalStation());
tempUnit.setStopStations(getStationList(tempResponse.getTripId().toString(), headers));
tempUnit.setPriceForSecondClassSeat(tempResponse.getPriceForEconomyClass());
tempUnit.setPriceForFirstClassSeat(tempResponse.getPriceForConfortClass());
tempUnit.setEndTime(tempResponse.getEndTime());
tempUnit.setStartTime(tempResponse.getStartTime());
units.add(tempUnit);
}
return new Response<>(1, "Success", units);
}
@Override
public Response searchQuickestResult(RoutePlanInfo info, HttpHeaders headers) {
//1.Violence pulls out all the results of travel-service and travle2-service
TripInfo queryInfo = new TripInfo();
queryInfo.setStartPlace(info.getStartStation());
queryInfo.setEndPlace(info.getEndStation());
queryInfo.setDepartureTime(info.getTravelDate());
ArrayList<TripResponse> highSpeed = getTripFromHighSpeedTravelServive(queryInfo, headers);
ArrayList<TripResponse> normalTrain = getTripFromNormalTrainTravelService(queryInfo, headers);
//2.Sort by time
ArrayList<TripResponse> finalResult = new ArrayList<>();
for (TripResponse tr : highSpeed) {
finalResult.add(tr);
}
for (TripResponse tr : normalTrain) {
finalResult.add(tr);
}
long minTime;
int minIndex = -1;
int size = Math.min(finalResult.size(), 5);
ArrayList<TripResponse> returnResult = new ArrayList<>();
for (int i = 0; i < size; i++) {
minTime = Long.MAX_VALUE;
for (int j = 0; j < finalResult.size(); j++) {
TripResponse thisRes = finalResult.get(j);
Date endTime = StringUtils.String2Date(thisRes.getEndTime());
Date startTime = StringUtils.String2Date(thisRes.getStartTime());
if (endTime.getTime() - startTime.getTime() < minTime) {
minTime = endTime.getTime() - startTime.getTime();
minIndex = j;
}
}
returnResult.add(finalResult.get(minIndex));
finalResult.remove(minIndex);
}
ArrayList<RoutePlanResultUnit> units = new ArrayList<>();
for (int i = 0; i < returnResult.size(); i++) {
TripResponse tempResponse = returnResult.get(i);
RoutePlanResultUnit tempUnit = new RoutePlanResultUnit();
tempUnit.setTripId(tempResponse.getTripId().toString());
tempUnit.setTrainTypeName(tempResponse.getTrainTypeName());
tempUnit.setStartStation(tempResponse.getStartStation());
tempUnit.setEndStation(tempResponse.getTerminalStation());
tempUnit.setStopStations(getStationList(tempResponse.getTripId().toString(), headers));
tempUnit.setPriceForSecondClassSeat(tempResponse.getPriceForEconomyClass());
tempUnit.setPriceForFirstClassSeat(tempResponse.getPriceForConfortClass());
tempUnit.setStartTime(tempResponse.getStartTime());
tempUnit.setEndTime(tempResponse.getEndTime());
units.add(tempUnit);
}
return new Response<>(1, "Success", units);
}
@Override
public Response searchMinStopStations(RoutePlanInfo info, HttpHeaders headers) {
String fromStationId = info.getStartStation();
String toStationId = info.getEndStation();
RoutePlanServiceImpl.LOGGER.info("[searchMinStopStations][Start and Finish][From Id: {} To: {}]", fromStationId , toStationId);
//1.Get the route through the two stations
HttpEntity requestEntity = new HttpEntity(null);
String route_service_url = getServiceUrl("ts-route-service");
ResponseEntity<Response<ArrayList<Route>>> re = restTemplate.exchange(
route_service_url + "/api/v1/routeservice/routes/" + info.getStartStation() + "/" + info.getEndStation(),
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<Route>>>() {
});
ArrayList<Route> routeList = re.getBody().getData();
RoutePlanServiceImpl.LOGGER.info("[searchMinStopStations][Get the route][Candidate Route Number: {}]", routeList.size());
//2.Calculate how many stops there are between the two stations
ArrayList<Integer> gapList = new ArrayList<>();
for (int i = 0; i < routeList.size(); i++) {
int indexStart = routeList.get(i).getStations().indexOf(fromStationId);
int indexEnd = routeList.get(i).getStations().indexOf(toStationId);
gapList.add(indexEnd - indexStart);
}
//3.Pick the routes with the fewest stops
ArrayList<String> resultRoutes = new ArrayList<>();
int size = Math.min(5, routeList.size());
for (int i = 0; i < size; i++) {
int minIndex = 0;
int tempMinGap = Integer.MAX_VALUE;
for (int j = 0; j < gapList.size(); j++) {
if (gapList.get(j) < tempMinGap) {
tempMinGap = gapList.get(j);
minIndex = j;
}
}
resultRoutes.add(routeList.get(minIndex).getId());
routeList.remove(minIndex);
gapList.remove(minIndex);
}
//4.Depending on the route, go to travel-service or travel2service to get the train information
requestEntity = new HttpEntity(resultRoutes, null);
String travel_service_url=getServiceUrl("ts-travel-service");
ResponseEntity<Response<ArrayList<ArrayList<Trip>>>> re2 = restTemplate.exchange(
travel_service_url + "/api/v1/travelservice/trips/routes",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<ArrayList<Trip>>>>() {
});
ArrayList<ArrayList<Trip>> travelTrips = re2.getBody().getData();
String travel2_service_url=getServiceUrl("ts-travel2-service");
re2 = restTemplate.exchange(
travel2_service_url + "/api/v1/travel2service/trips/routes",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<ArrayList<Trip>>>>() {
});
ArrayList<ArrayList<Trip>> travel2Trips = re2.getBody().getData();
//Merge query results
ArrayList<ArrayList<Trip>> finalTripResult = new ArrayList<>();
for (int i = 0; i < travel2Trips.size(); i++) {
ArrayList<Trip> tempList = travel2Trips.get(i);
tempList.addAll(travelTrips.get(i));
finalTripResult.add(tempList);
}
RoutePlanServiceImpl.LOGGER.info("[searchMinStopStations][Get train Information][Trips Num: {}]", finalTripResult.size());
//5.Then, get the price and the station information according to the train information
ArrayList<Trip> trips = new ArrayList<>();
for (ArrayList<Trip> tempTrips : finalTripResult) {
trips.addAll(tempTrips);
}
ArrayList<RoutePlanResultUnit> tripResponses = new ArrayList<>();
ResponseEntity<Response<TripAllDetail>> re3;
for (Trip trip : trips) {
TripResponse tripResponse;
TripAllDetailInfo allDetailInfo = new TripAllDetailInfo();
allDetailInfo.setTripId(trip.getTripId().toString());
allDetailInfo.setTravelDate(info.getTravelDate());
allDetailInfo.setFrom(info.getStartStation());
allDetailInfo.setTo(info.getEndStation());
requestEntity = new HttpEntity(allDetailInfo, null);
String requestUrl = "";
if (trip.getTripId().toString().charAt(0) == 'D' || trip.getTripId().toString().charAt(0) == 'G') {
requestUrl = travel_service_url + "/api/v1/travelservice/trip_detail";
} else {
requestUrl = travel2_service_url + "/api/v1/travel2service/trip_detail";
}
re3 = restTemplate.exchange(
requestUrl,
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<TripAllDetail>>() {
});
TripAllDetail tripAllDetail = re3.getBody().getData();
tripResponse = tripAllDetail.getTripResponse();
RoutePlanResultUnit unit = new RoutePlanResultUnit();
unit.setTripId(trip.getTripId().toString());
unit.setTrainTypeName(tripResponse.getTrainTypeName());
unit.setStartStation(tripResponse.getStartStation());
unit.setEndStation(tripResponse.getTerminalStation());
unit.setStartTime(tripResponse.getStartTime());
unit.setEndTime(tripResponse.getEndTime());
unit.setPriceForFirstClassSeat(tripResponse.getPriceForConfortClass());
unit.setPriceForSecondClassSeat(tripResponse.getPriceForEconomyClass());
//Go get the roadmap according to routeid
String routeId = trip.getRouteId();
Route tripRoute = getRouteByRouteId(routeId, headers);
if (tripRoute != null) {
unit.setStopStations(tripRoute.getStations());
}
tripResponses.add(unit);
}
RoutePlanServiceImpl.LOGGER.info("[searchMinStopStations][Trips Response Unit Num: {}]", tripResponses.size());
return new Response<>(1, "Success.", tripResponses);
}
private Route getRouteByRouteId(String routeId, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(null);
String route_service_url = getServiceUrl("ts-route-service");
ResponseEntity<Response<Route>> re = restTemplate.exchange(
route_service_url + "/api/v1/routeservice/routes/" + routeId,
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<Route>>() {
});
Response<Route> result = re.getBody();
if (result.getStatus() == 0) {
RoutePlanServiceImpl.LOGGER.error("[getRouteByRouteId][Get Route By Id Fail][RouteId: {}]", routeId);
return null;
} else {
RoutePlanServiceImpl.LOGGER.info("[getRouteByRouteId][Get Route By Id Success]");
return result.getData();
}
}
private ArrayList<TripResponse> getTripFromHighSpeedTravelServive(TripInfo info, HttpHeaders headers) {
RoutePlanServiceImpl.LOGGER.info("[getTripFromHighSpeedTravelServive][trip info: {}]", info);
HttpEntity requestEntity = new HttpEntity(info, null);
String travel_service_url=getServiceUrl("ts-travel-service");
ResponseEntity<Response<ArrayList<TripResponse>>> re = restTemplate.exchange(
travel_service_url + "/api/v1/travelservice/trips/left",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<TripResponse>>>() {
});
ArrayList<TripResponse> tripResponses = re.getBody().getData();
RoutePlanServiceImpl.LOGGER.info("[getTripFromHighSpeedTravelServive][Route Plan Get Trip][Size:{}]", tripResponses.size());
return tripResponses;
}
private ArrayList<TripResponse> getTripFromNormalTrainTravelService(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>>>() {
});
ArrayList<TripResponse> list = re.getBody().getData();
RoutePlanServiceImpl.LOGGER.info("[getTripFromNormalTrainTravelService][Route Plan Get TripOther][Size:{}]", list.size());
return list;
}
private List<String> getStationList(String tripId, HttpHeaders headers) {
String path;
String travel_service_url=getServiceUrl("ts-travel-service");
String travel2_service_url=getServiceUrl("ts-travel2-service");
if (tripId.charAt(0) == 'G' || tripId.charAt(0) == 'D') {
path = travel_service_url + "/api/v1/travelservice/routes/" + tripId;
} else {
path = travel2_service_url + "/api/v1/travel2service/routes/" + tripId;
}
HttpEntity requestEntity = new HttpEntity(null);
ResponseEntity<Response<Route>> re = restTemplate.exchange(
path,
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<Route>>() {
});
Route route = re.getBody().getData();
return route.getStations();
}
}
| 16,316 | 44.705882 | 135 |
java
|
train-ticket
|
train-ticket-master/ts-route-plan-service/src/test/java/plan/controller/RoutePlanControllerTest.java
|
package plan.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.HttpHeaders;
import org.springframework.http.MediaType;
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.RoutePlanInfo;
import plan.service.RoutePlanService;
@RunWith(JUnit4.class)
public class RoutePlanControllerTest {
@InjectMocks
private RoutePlanController adminTravelController;
@Mock
private RoutePlanService routePlanService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(adminTravelController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/routeplanservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ RoutePlan Service ] !"));
}
@Test
public void testGetCheapestRoutes() throws Exception {
RoutePlanInfo info = new RoutePlanInfo();
Mockito.when(routePlanService.searchCheapestResult(Mockito.any(RoutePlanInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/routeplanservice/routePlan/cheapestRoute").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetQuickestRoutes() throws Exception {
RoutePlanInfo info = new RoutePlanInfo();
Mockito.when(routePlanService.searchQuickestResult(Mockito.any(RoutePlanInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/routeplanservice/routePlan/quickestRoute").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetMinStopStations() throws Exception {
RoutePlanInfo info = new RoutePlanInfo();
Mockito.when(routePlanService.searchMinStopStations(Mockito.any(RoutePlanInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/routeplanservice/routePlan/minStopStations").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 3,784 | 45.728395 | 183 |
java
|
train-ticket
|
train-ticket-master/ts-route-plan-service/src/test/java/plan/service/RoutePlanServiceImplTest.java
|
package plan.service;
import edu.fudan.common.entity.Trip;
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.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import edu.fudan.common.entity.RoutePlanInfo;
import edu.fudan.common.entity.Route;
import java.util.ArrayList;
import java.util.Date;
@RunWith(JUnit4.class)
public class RoutePlanServiceImplTest {
@InjectMocks
private RoutePlanServiceImpl routePlanServiceImpl;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testSearchCheapestResult() {
RoutePlanInfo info = new RoutePlanInfo("form_station", "to_station", "", 1);
//mock getTripFromHighSpeedTravelServive() and getTripFromNormalTrainTravelService()
ArrayList<TripResponse> tripResponses = new ArrayList<>();
Response<ArrayList<TripResponse>> response1 = new Response<>(null, null, tripResponses);
ResponseEntity<Response<ArrayList<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 = routePlanServiceImpl.searchCheapestResult(info, headers);
Assert.assertEquals(new Response<>(1, "Success", new ArrayList<>()), result);
}
@Test
public void testSearchQuickestResult() {
RoutePlanInfo info = new RoutePlanInfo("form_station", "to_station", "", 1);
//mock getTripFromHighSpeedTravelServive() and getTripFromNormalTrainTravelService()
ArrayList<TripResponse> tripResponses = new ArrayList<>();
Response<ArrayList<TripResponse>> response1 = new Response<>(null, null, tripResponses);
ResponseEntity<Response<ArrayList<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 = routePlanServiceImpl.searchQuickestResult(info, headers);
Assert.assertEquals(new Response<>(1, "Success", new ArrayList<>()), result);
}
@Test
public void testSearchMinStopStations() {
RoutePlanInfo info = new RoutePlanInfo("form_station", "to_station", "", 1);
Response<String> response = new Response(null, null, "");
ResponseEntity<Response<String>> re = new ResponseEntity<>(response, HttpStatus.OK);
ArrayList<Route> routeArrayList = new ArrayList<>();
Response<ArrayList<Route>> response2 = new Response<>(null, null, routeArrayList);
ResponseEntity<Response<ArrayList<Route>>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
ArrayList<ArrayList<Trip>> tripLists = new ArrayList<>();
Response<ArrayList<ArrayList<Trip>>> response3 = new Response<>(null, null, tripLists);
ResponseEntity<Response<ArrayList<ArrayList<Trip>>>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re).thenReturn(re).thenReturn(re2).thenReturn(re3).thenReturn(re3);
Response result = routePlanServiceImpl.searchMinStopStations(info, headers);
Assert.assertEquals("Success.", result.getMsg());
}
}
| 4,263 | 42.070707 | 114 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/RouteApplication.java
|
package route;
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 RouteApplication {
public static void main(String[] args) {
SpringApplication.run(RouteApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,177 | 31.722222 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/config/SecurityConfig.java
|
package route.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/routeservice/**").permitAll()
.antMatchers(HttpMethod.POST, "/api/v1/routeservice/routes").hasAnyRole("ADMIN")
.antMatchers(HttpMethod.DELETE, "/api/v1/routeservice/routes/*").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,471 | 40.333333 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/controller/RouteController.java
|
package route.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.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import route.entity.RouteInfo;
import route.service.RouteService;
import java.util.List;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/routeservice")
public class RouteController {
private static final Logger LOGGER = LoggerFactory.getLogger(RouteController.class);
@Autowired
private RouteService routeService;
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ Route Service ] !";
}
@PostMapping(path = "/routes")
public ResponseEntity<Response> createAndModifyRoute(@RequestBody RouteInfo createAndModifyRouteInfo, @RequestHeader HttpHeaders headers) {
RouteController.LOGGER.info("[createAndModify][Create route][start: {}, end: {}]", createAndModifyRouteInfo.getStartStation(),createAndModifyRouteInfo.getEndStation());
return ok(routeService.createAndModify(createAndModifyRouteInfo, headers));
}
@DeleteMapping(path = "/routes/{routeId}")
public HttpEntity deleteRoute(@PathVariable String routeId, @RequestHeader HttpHeaders headers) {
RouteController.LOGGER.info("[deleteRoute][Delete route][RouteId: {}]", routeId);
return ok(routeService.deleteRoute(routeId, headers));
}
@GetMapping(path = "/routes/{routeId}")
public HttpEntity queryById(@PathVariable String routeId, @RequestHeader HttpHeaders headers) {
RouteController.LOGGER.info("[getRouteById][Query route by id][RouteId: {}]", routeId);
return ok(routeService.getRouteById(routeId, headers));
}
@PostMapping(path = "/routes/byIds")
public HttpEntity queryByIds(@RequestBody List<String> routeIds, @RequestHeader HttpHeaders headers) {
RouteController.LOGGER.info("[getRouteById][Query route by id][RouteId: {}]", routeIds);
return ok(routeService.getRouteByIds(routeIds, headers));
}
@GetMapping(path = "/routes")
public HttpEntity queryAll(@RequestHeader HttpHeaders headers) {
RouteController.LOGGER.info("[getAllRoutes][Query all routes]");
return ok(routeService.getAllRoutes(headers));
}
@GetMapping(path = "/routes/{start}/{end}")
public HttpEntity queryByStartAndTerminal(@PathVariable String start,
@PathVariable String end,
@RequestHeader HttpHeaders headers) {
RouteController.LOGGER.info("[getRouteByStartAndEnd][Query routes][start: {}, end: {}]", start, end);
return ok(routeService.getRouteByStartAndEnd(start, end, headers));
}
}
| 2,991 | 41.140845 | 176 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/entity/Route.java
|
package route.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.models.auth.In;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.util.List;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@Entity
@JsonIgnoreProperties(ignoreUnknown = true)
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class Route {
@Id
@Column(length = 36)
private String id;
@ElementCollection(targetClass = String.class)
@OrderColumn
private List<String> stations;
@ElementCollection(targetClass = Integer.class)
@OrderColumn
private List<Integer> distances;
private String startStation;
private String endStation;
public Route(){
this.id = UUID.randomUUID().toString();
}
public Route(String id, List<String> stations, List<Integer> distances, String startStation, String endStation) {
this.id = id;
this.stations = stations;
this.distances = distances;
this.startStation = startStation;
this.endStation = endStation;
}
public Route(List<String> stations, List<Integer> distances, String startStation, String endStation) {
this.id = UUID.randomUUID().toString();
this.stations = stations;
this.distances = distances;
this.startStation = startStation;
this.endStation = endStation;
}
}
| 1,539 | 24.666667 | 117 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/entity/RouteInfo.java
|
package route.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author fdse
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RouteInfo {
private String Id;
private String startStation;
private String endStation;
private String stationList;
private String distanceList;
}
| 364 | 13.6 | 33 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/init/InitData.java
|
package route.init;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import route.entity.RouteInfo;
import route.service.RouteService;
/**
* @author fdse
*/
@Component
public class InitData implements CommandLineRunner {
@Autowired
RouteService routeService;
String shanghai = "shanghai";
String taiyuan = "taiyuan";
String nanjing = "nanjing";
@Override
public void run(String... args)throws Exception{
RouteInfo info = new RouteInfo();
info.setId("0b23bd3e-876a-4af3-b920-c50a90c90b04");
info.setStartStation(shanghai);
info.setEndStation(taiyuan);
info.setStationList("shanghai,nanjing,shijiazhuang,taiyuan");
info.setDistanceList("0,350,1000,1300");
routeService.createAndModify(info,null);
info.setId("9fc9c261-3263-4bfa-82f8-bb44e06b2f52");
info.setStartStation(nanjing);
info.setEndStation("beijing");
info.setStationList("nanjing,xuzhou,jinan,beijing");
info.setDistanceList("0,500,700,1200");
routeService.createAndModify(info,null);
info.setId("d693a2c5-ef87-4a3c-bef8-600b43f62c68");
info.setStartStation(taiyuan);
info.setEndStation(shanghai);
info.setStationList("taiyuan,shijiazhuang,nanjing,shanghai");
info.setDistanceList("0,300,950,1300");
routeService.createAndModify(info,null);
info.setId("20eb7122-3a11-423f-b10a-be0dc5bce7db");
info.setStartStation(shanghai);
info.setEndStation(taiyuan);
info.setStationList("shanghai,taiyuan");
info.setDistanceList("0,1300");
routeService.createAndModify(info,null);
info.setId("1367db1f-461e-4ab7-87ad-2bcc05fd9cb7");
info.setStartStation("shanghaihongqiao");
info.setEndStation("hangzhou");
info.setStationList("shanghaihongqiao,jiaxingnan,hangzhou");
info.setDistanceList("0,150,300");
routeService.createAndModify(info,null);
info.setId("92708982-77af-4318-be25-57ccb0ff69ad");
info.setStartStation(nanjing);
info.setEndStation(shanghai);
info.setStationList("nanjing,zhenjiang,wuxi,suzhou,shanghai");
info.setDistanceList("0,100,150,200,250");
routeService.createAndModify(info,null);
info.setId("aefcef3f-3f42-46e8-afd7-6cb2a928bd3d");
info.setStartStation(nanjing);
info.setEndStation(shanghai);
info.setStationList("nanjing,shanghai");
info.setDistanceList("0,250");
routeService.createAndModify(info,null);
info.setId("a3f256c1-0e43-4f7d-9c21-121bf258101f");
info.setStartStation(nanjing);
info.setEndStation(shanghai);
info.setStationList("nanjing,suzhou,shanghai");
info.setDistanceList("0,200,250");
routeService.createAndModify(info,null);
info.setId("084837bb-53c8-4438-87c8-0321a4d09917");
info.setStartStation("suzhou");
info.setEndStation(shanghai);
info.setStationList("suzhou,shanghai");
info.setDistanceList("0,50");
routeService.createAndModify(info,null);
info.setId("f3d4d4ef-693b-4456-8eed-59c0d717dd08");
info.setStartStation(shanghai);
info.setEndStation("suzhou");
info.setStationList("shanghai,suzhou");
info.setDistanceList("0,50");
routeService.createAndModify(info,null);
}
}
| 3,519 | 34.555556 | 70 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/repository/RouteRepository.java
|
package route.repository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import route.entity.Route;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
/**
* @author fdse
*/
@Repository
public interface RouteRepository extends CrudRepository<Route, String> {
/**
* find route by id
*
* @param id id
* @return Route
*/
Optional<Route> findById(String id);
/**
* find route by ids
*
* @param ids ids
* @return Route
*/
@Query(value="SELECT * from route where id in ?1", nativeQuery = true)
List<Route> findByIds(List<String> ids);
/**
* find all routes
*
* @return ArrayList<Route>
*/
@Override
ArrayList<Route> findAll();
/**
* remove route via id
*
* @param id id
*/
void removeRouteById(String id);
/**
* return route with id from StartStationId to TerminalStationId
*
* @param startStation Start Station Name
* @param endStation end Station Name
* @return ArrayList<Route>
*/
ArrayList<Route> findByStartStationAndEndStation(String startStation, String endStation);
}
| 1,292 | 20.915254 | 93 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/service/RouteService.java
|
package route.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import route.entity.*;
import java.util.List;
/**
* @author fdse
*/
public interface RouteService {
/**
* get route with id
*
* @param startId start station id
* @param terminalId terminal station id
* @param headers headers
* @return Response
*/
Response getRouteByStartAndEnd(String startId, String terminalId, HttpHeaders headers);
/**
* get all routes
*
* @param headers headers
* @return Response
*/
Response getAllRoutes(HttpHeaders headers);
/**
* get route by id
*
* @param routeId route id
* @param headers headers
* @return Response
*/
Response getRouteById(String routeId, HttpHeaders headers);
/**
* get route by ids
*
* @param routeIds route ids
* @param headers headers
* @return Response
*/
Response getRouteByIds(List<String> routeIds, HttpHeaders headers);
/**
* delete route by id
*
* @param routeId route id
* @param headers headers
* @return Response
*/
Response deleteRoute(String routeId, HttpHeaders headers);
/**
* create route and modify
*
* @param info info
* @param headers headers
* @return Response
*/
Response createAndModify(RouteInfo info, HttpHeaders headers);
}
| 1,444 | 19.642857 | 91 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/main/java/route/service/RouteServiceImpl.java
|
package route.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 org.springframework.transaction.annotation.Transactional;
import route.entity.Route;
import route.entity.RouteInfo;
import route.repository.RouteRepository;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
/**
* @author fdse
*/
@Service
public class RouteServiceImpl implements RouteService {
@Autowired
private RouteRepository routeRepository;
private static final Logger LOGGER = LoggerFactory.getLogger(RouteServiceImpl.class);
String success = "Success";
@Override
public Response createAndModify(RouteInfo info, HttpHeaders headers) {
RouteServiceImpl.LOGGER.info("[createAndModify][Create and modify start and end][Start: {} End: {}]", info.getStartStation(), info.getEndStation());
String[] stations = info.getStationList().split(",");
String[] distances = info.getDistanceList().split(",");
List<String> stationList = new ArrayList<>();
List<Integer> distanceList = new ArrayList<>();
if (stations.length != distances.length) {
RouteServiceImpl.LOGGER.error("[createAndModify][Create and modify error][Station number not equal to distance number][RouteId: {}]",info.getId());
return new Response<>(0, "Station Number Not Equal To Distance Number", null);
}
for (int i = 0; i < stations.length; i++) {
stationList.add(stations[i]);
distanceList.add(Integer.parseInt(distances[i]));
}
int maxIdArrayLen = 32;
Route route = new Route();
if (info.getId() == null || info.getId().length() < maxIdArrayLen) {
route.setId(UUID.randomUUID().toString());
}else{
Optional<Route> routeOld = routeRepository.findById(info.getId());
if(routeOld.isPresent()) {
route = routeOld.get();
} else {
route.setId(info.getId());
}
}
route.setStartStation(info.getStartStation());
route.setEndStation(info.getEndStation());
route.setStations(stationList);
route.setDistances(distanceList);
routeRepository.save(route);
return new Response<>(1, "Save and Modify success", route);
}
@Override
@Transactional
public Response deleteRoute(String routeId, HttpHeaders headers) {
routeRepository.removeRouteById(routeId);
Optional<Route> route = routeRepository.findById(routeId);
if (!route.isPresent()) {
return new Response<>(1, "Delete Success", routeId);
} else {
RouteServiceImpl.LOGGER.error("[deleteRoute][Delete error][Route not found][RouteId: {}]",routeId);
return new Response<>(0, "Delete failed, Reason unKnown with this routeId", routeId);
}
}
@Override
public Response getRouteById(String routeId, HttpHeaders headers) {
Optional<Route> route = routeRepository.findById(routeId);
if (!route.isPresent()) {
RouteServiceImpl.LOGGER.error("[getRouteById][Find route error][Route not found][RouteId: {}]",routeId);
return new Response<>(0, "No content with the routeId", null);
} else {
return new Response<>(1, success, route);
}
}
@Override
public Response getRouteByIds(List<String> routeIds, HttpHeaders headers) {
List<Route> routes = routeRepository.findByIds(routeIds);
if (routes == null || routes.isEmpty()) {
RouteServiceImpl.LOGGER.error("[getRouteById][Find route error][Route not found][RouteIds: {}]",routeIds);
return new Response<>(0, "No content with the routeIds", null);
} else {
return new Response<>(1, success, routes);
}
}
@Override
public Response getRouteByStartAndEnd(String startId, String terminalId, HttpHeaders headers) {
ArrayList<Route> routes = routeRepository.findAll();
RouteServiceImpl.LOGGER.info("[getRouteByStartAndEnd][Find All][size:{}]", routes.size());
List<Route> resultList = new ArrayList<>();
for (Route route : routes) {
if (route.getStations().contains(startId) &&
route.getStations().contains(terminalId) &&
route.getStations().indexOf(startId) < route.getStations().indexOf(terminalId)) {
resultList.add(route);
}
}
if (!resultList.isEmpty()) {
return new Response<>(1, success, resultList);
} else {
RouteServiceImpl.LOGGER.warn("[getRouteByStartAndEnd][Find by start and terminal warn][Routes not found][startId: {},terminalId: {}]",startId,terminalId);
return new Response<>(0, "No routes with the startId and terminalId", null);
}
}
@Override
public Response getAllRoutes(HttpHeaders headers) {
ArrayList<Route> routes = routeRepository.findAll();
if (routes != null && !routes.isEmpty()) {
return new Response<>(1, success, routes);
} else {
RouteServiceImpl.LOGGER.warn("[getAllRoutes][Find all routes warn][{}]","No Content");
return new Response<>(0, "No Content", null);
}
}
}
| 5,527 | 40.253731 | 166 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/test/java/route/controller/RouteControllerTest.java
|
package route.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 route.entity.RouteInfo;
import route.service.RouteService;
@RunWith(JUnit4.class)
public class RouteControllerTest {
@InjectMocks
private RouteController routeController;
@Mock
private RouteService routeService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(routeController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/routeservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Route Service ] !"));
}
@Test
public void testCreateAndModifyRoute() throws Exception {
RouteInfo createAndModifyRouteInfo = new RouteInfo();
Mockito.when(routeService.createAndModify(Mockito.any(RouteInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(createAndModifyRouteInfo);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/routeservice/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 testDeleteRoute() throws Exception {
Mockito.when(routeService.deleteRoute(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/routeservice/routes/route_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryById() throws Exception {
Mockito.when(routeService.getRouteById(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/routeservice/routes/route_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryAll() throws Exception {
Mockito.when(routeService.getAllRoutes(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/routeservice/routes"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryByStartAndTerminal() throws Exception {
Mockito.when(routeService.getRouteByStartAndEnd(Mockito.anyString(), Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/routeservice/routes/start_id/terminal_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 4,304 | 44.797872 | 160 |
java
|
train-ticket
|
train-ticket-master/ts-route-service/src/test/java/route/service/RouteServiceImplTest.java
|
package route.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.http.HttpHeaders;
import route.entity.Route;
import route.entity.RouteInfo;
import route.repository.RouteRepository;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@RunWith(JUnit4.class)
public class RouteServiceImplTest {
@InjectMocks
private RouteServiceImpl routeServiceImpl;
@Mock
private RouteRepository routeRepository;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testCreateAndModify1() {
RouteInfo info = new RouteInfo("id", "start_station", "end_station", "shanghai", "5,10");
Response result = routeServiceImpl.createAndModify(info, headers);
Assert.assertEquals(new Response<>(0, "Station Number Not Equal To Distance Number", null), result);
}
@Test
public void testCreateAndModify2() {
RouteInfo info = new RouteInfo("id", "start_station", "end_station", "shanghai", "5");
Mockito.when(routeRepository.save(Mockito.any(Route.class))).thenReturn(null);
Response result = routeServiceImpl.createAndModify(info, headers);
Assert.assertEquals("Save Success", result.getMsg());
}
@Test
public void testCreateAndModify3() {
RouteInfo info = new RouteInfo("id123456789", "start_station", "end_station", "shanghai", "5");
Mockito.when(routeRepository.findById(Mockito.anyString())).thenReturn(null);
Mockito.when(routeRepository.save(Mockito.any(Route.class))).thenReturn(null);
Response result = routeServiceImpl.createAndModify(info, headers);
Assert.assertEquals("Modify success", result.getMsg());
}
@Test
public void testDeleteRoute1() {
Mockito.doNothing().doThrow(new RuntimeException()).when(routeRepository).removeRouteById(Mockito.anyString());
Mockito.when(routeRepository.findById(Mockito.anyString())).thenReturn(null);
Response result = routeServiceImpl.deleteRoute("route_id", headers);
Assert.assertEquals(new Response<>(1, "Delete Success", "route_id"), result);
}
@Test
public void testDeleteRoute2() {
Route route = new Route();
Mockito.doNothing().doThrow(new RuntimeException()).when(routeRepository).removeRouteById(Mockito.anyString());
Mockito.when(routeRepository.findById(Mockito.anyString()).get()).thenReturn(route);
Response result = routeServiceImpl.deleteRoute("route_id", headers);
Assert.assertEquals(new Response<>(0, "Delete failed, Reason unKnown with this routeId", "route_id"), result);
}
@Test
public void testGetRouteById1() {
Mockito.when(routeRepository.findById(Mockito.anyString())).thenReturn(null);
Response result = routeServiceImpl.getRouteById("route_id", headers);
Assert.assertEquals(new Response<>(0, "No content with the routeId", null), result);
}
@Test
public void testGetRouteById2() {
Route route = new Route();
Mockito.when(routeRepository.findById(Mockito.anyString()).get()).thenReturn(route);
Response result = routeServiceImpl.getRouteById("route_id", headers);
Assert.assertEquals(new Response<>(1, "Success", route), result);
}
@Test
public void testGetRouteByStartAndTerminal1() {
List<String> stations = new ArrayList<>();
stations.add("shanghai");
stations.add("nanjing");
List<Integer> distances = new ArrayList<>();
distances.add(5);
distances.add(10);
Route route = new Route(UUID.randomUUID().toString(), stations, distances, "shanghai", "nanjing");
ArrayList<Route> routes = new ArrayList<>();
routes.add(route);
Mockito.when(routeRepository.findAll()).thenReturn(routes);
Response result = routeServiceImpl.getRouteByStartAndEnd("shanghai", "nanjing", headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetRouteByStartAndTerminal2() {
ArrayList<Route> routes = new ArrayList<>();
Mockito.when(routeRepository.findAll()).thenReturn(routes);
Response result = routeServiceImpl.getRouteByStartAndEnd("shanghai", "nanjing", headers);
Assert.assertEquals("No routes with the startId and terminalId", result.getMsg());
}
@Test
public void testGetAllRoutes1() {
ArrayList<Route> routes = new ArrayList<>();
routes.add(new Route());
Mockito.when(routeRepository.findAll()).thenReturn(routes);
Response result = routeServiceImpl.getAllRoutes(headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetAllRoutes2() {
Mockito.when(routeRepository.findAll()).thenReturn(null);
Response result = routeServiceImpl.getAllRoutes(headers);
Assert.assertEquals("No Content", result.getMsg());
}
}
| 5,292 | 38.207407 | 119 |
java
|
train-ticket
|
train-ticket-master/ts-seat-service/src/main/java/seat/SeatApplication.java
|
package seat;
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 SeatApplication {
public static void main(String[] args) {
SpringApplication.run(SeatApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,174 | 31.638889 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-seat-service/src/main/java/seat/config/SecurityConfig.java
|
package seat.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/seatservice/**").permitAll()
.antMatchers(HttpMethod.POST, "/api/v1/seatservice/seats").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,367 | 39.095238 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-seat-service/src/main/java/seat/controller/SeatController.java
|
package seat.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.Seat;
import seat.service.SeatService;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/seatservice")
public class SeatController {
@Autowired
private SeatService seatService;
private static final Logger LOGGER = LoggerFactory.getLogger(SeatController.class);
@GetMapping(path = "/welcome")
public String home() {
return "Welcome to [ Seat Service ] !";
}
/**
* Assign seats by seat request
*
* @param seatRequest seat request
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@PostMapping(value = "/seats")
public HttpEntity create(@RequestBody Seat seatRequest, @RequestHeader HttpHeaders headers) {
SeatController.LOGGER.info("[distributeSeat][Create seat][TravelDate: {},TrainNumber: {},SeatType: {}]",seatRequest.getTravelDate(),seatRequest.getTrainNumber(),seatRequest.getSeatType());
return ok(seatService.distributeSeat(seatRequest, headers));
}
/**
* get left ticket of interval
* query specific interval residual
*
* @param seatRequest seat request
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@PostMapping(value = "/seats/left_tickets")
public HttpEntity getLeftTicketOfInterval(@RequestBody Seat seatRequest, @RequestHeader HttpHeaders headers) {
// int
SeatController.LOGGER.info("[getLeftTicketOfInterval][Get left ticket of interval][TravelDate: {},TrainNumber: {},SeatType: {}]",seatRequest.getTravelDate(),seatRequest.getTrainNumber(),seatRequest.getSeatType());
return ok(seatService.getLeftTicketOfInterval(seatRequest, headers));
}
}
| 2,088 | 32.693548 | 221 |
java
|
train-ticket
|
train-ticket-master/ts-seat-service/src/main/java/seat/service/SeatService.java
|
package seat.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import edu.fudan.common.entity.Seat;
/**
* @author fdse
*/
public interface SeatService {
Response distributeSeat(Seat seatRequest, HttpHeaders headers);
Response getLeftTicketOfInterval(Seat seatRequest, HttpHeaders headers);
}
| 348 | 22.266667 | 76 |
java
|
train-ticket
|
train-ticket-master/ts-seat-service/src/main/java/seat/service/SeatServiceImpl.java
|
package seat.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.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 java.util.List;
import java.util.Random;
import java.util.Set;
/**
* @author fdse
*/
@Service
public class SeatServiceImpl implements SeatService {
@Autowired
RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(SeatServiceImpl.class);
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
@Override
public Response distributeSeat(Seat seatRequest, HttpHeaders headers) {
Response<Route> routeResult;
LeftTicketInfo leftTicketInfo;
TrainType trainTypeResult = null;
ResponseEntity<Response<Route>> re;
ResponseEntity<Response<TrainType>> re2;
ResponseEntity<Response<LeftTicketInfo>> re3;
//Distinguish G\D from other trains
String trainNumber = seatRequest.getTrainNumber();
if (trainNumber.startsWith("G") || trainNumber.startsWith("D")) {
SeatServiceImpl.LOGGER.info("[distributeSeat][TrainNumber start][G or D]");
HttpEntity requestEntity = new HttpEntity(null);
//Call the microservice to query for residual Ticket information: the set of the Ticket sold for the specified seat type
requestEntity = new HttpEntity(seatRequest, null);
String order_service_url=getServiceUrl("ts-order-service");
re3 = restTemplate.exchange(
order_service_url + "/api/v1/orderservice/order/tickets",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<LeftTicketInfo>>() {
});
SeatServiceImpl.LOGGER.info("[distributeSeat][Left ticket info][info is : {}]", re3.getBody().toString());
leftTicketInfo = re3.getBody().getData();
} else {
SeatServiceImpl.LOGGER.info("[distributeSeat][TrainNumber start][Other Capital Except D and G]");
//Call the microservice to query for residual Ticket information: the set of the Ticket sold for the specified seat type
HttpEntity requestEntity = new HttpEntity(seatRequest, null);
String order_other_service_url=getServiceUrl("ts-order-other-service");
re3 = restTemplate.exchange(
order_other_service_url + "/api/v1/orderOtherService/orderOther/tickets",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<LeftTicketInfo>>() {
});
SeatServiceImpl.LOGGER.info("[distributeSeat][Left ticket info][info is : {}]", re3.getBody().toString());
leftTicketInfo = re3.getBody().getData();
}
//Assign seats
List<String> stationList = seatRequest.getStations();
int seatTotalNum = seatRequest.getTotalNum();
String startStation = seatRequest.getStartStation();
Ticket ticket = new Ticket();
ticket.setStartStation(startStation);
ticket.setDestStation(seatRequest.getDestStation());
//Assign new tickets
Random rand = new Random();
int range = seatTotalNum;
int seat = rand.nextInt(range) + 1;
if(leftTicketInfo != null) {
Set<Ticket> soldTickets = leftTicketInfo.getSoldTickets();
//Give priority to tickets already sold
for (Ticket soldTicket : soldTickets) {
String soldTicketDestStation = soldTicket.getDestStation();
//Tickets can be allocated if the sold ticket's end station before the start station of the request
if (stationList.indexOf(soldTicketDestStation) < stationList.indexOf(startStation)) {
ticket.setSeatNo(soldTicket.getSeatNo());
SeatServiceImpl.LOGGER.info("[distributeSeat][Assign new tickets][Use the previous distributed seat number][seat number:{}]", soldTicket.getSeatNo());
return new Response<>(1, "Use the previous distributed seat number!", ticket);
}
}
while (isContained(soldTickets, seat)) {
seat = rand.nextInt(range) + 1;
}
}
ticket.setSeatNo(seat);
SeatServiceImpl.LOGGER.info("[distributeSeat][Assign new tickets][Use a new seat number][seat number:{}]", seat);
return new Response<>(1, "Use a new seat number!", ticket);
}
private boolean isContained(Set<Ticket> soldTickets, int seat) {
//Check that the seat number has been used
boolean result = false;
for (Ticket soldTicket : soldTickets) {
if (soldTicket.getSeatNo() == seat) {
return true;
}
}
return result;
}
@Override
public Response getLeftTicketOfInterval(Seat seatRequest, HttpHeaders headers) {
int numOfLeftTicket = 0;
LeftTicketInfo leftTicketInfo;
ResponseEntity<Response<LeftTicketInfo>> re3;
//Distinguish G\D from other trains
String trainNumber = seatRequest.getTrainNumber();
SeatServiceImpl.LOGGER.info("[getLeftTicketOfInterval][Seat request][request:{}]", seatRequest.toString());
if (trainNumber.startsWith("G") || trainNumber.startsWith("D")) {
SeatServiceImpl.LOGGER.info("[getLeftTicketOfInterval][TrainNumber start with G|D][trainNumber:{}]", trainNumber);
//Call the micro service to query all the station information for the trains
HttpEntity requestEntity = new HttpEntity(seatRequest, null);
String order_service_url=getServiceUrl("ts-order-service");
re3 = restTemplate.exchange(
order_service_url + "/api/v1/orderservice/order/tickets",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<LeftTicketInfo>>() {
});
SeatServiceImpl.LOGGER.info("[getLeftTicketOfInterval][Get Order tickets result][result is {}]", re3);
leftTicketInfo = re3.getBody().getData();
} else {
SeatServiceImpl.LOGGER.info("[getLeftTicketOfInterval][TrainNumber start with other capital][trainNumber:{}]", trainNumber);
//Call the micro service to query all the station information for the trains
HttpEntity requestEntity = new HttpEntity(null);
//Call the micro service to query for residual Ticket information: the set of the Ticket sold for the specified seat type
requestEntity = new HttpEntity(seatRequest, null);
String order_other_service_url=getServiceUrl("ts-order-other-service");
re3 = restTemplate.exchange(
order_other_service_url + "/api/v1/orderOtherService/orderOther/tickets",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<LeftTicketInfo>>() {
});
SeatServiceImpl.LOGGER.info("[getLeftTicketOfInterval][Get Order tickets result][result is {}]", re3);
leftTicketInfo = re3.getBody().getData();
}
//Counting the seats remaining in certain sections
List<String> stationList = seatRequest.getStations();
int seatTotalNum = seatRequest.getTotalNum();
int solidTicketSize = 0;
if (leftTicketInfo != null) {
String startStation = seatRequest.getStartStation();
Set<Ticket> soldTickets = leftTicketInfo.getSoldTickets();
solidTicketSize = soldTickets.size();
//To find out if tickets already sold are available
for (Ticket soldTicket : soldTickets) {
String soldTicketDestStation = soldTicket.getDestStation();
//Tickets can be allocated if the sold ticket's end station before the start station of the request
if (stationList.indexOf(soldTicketDestStation) < stationList.indexOf(startStation)) {
SeatServiceImpl.LOGGER.info("[getLeftTicketOfInterval][Ticket available or sold][The previous distributed seat number is usable][{}]", soldTicket.getSeatNo());
numOfLeftTicket++;
}
}
}
//Count the unsold tickets
double direstPart = getDirectProportion(headers);
if (stationList.get(0).equals(seatRequest.getStartStation()) &&
stationList.get(stationList.size() - 1).equals(seatRequest.getDestStation())) {
//do nothing
} else {
direstPart = 1.0 - direstPart;
}
int unusedNum = (int) (seatTotalNum * direstPart) - solidTicketSize;
numOfLeftTicket += unusedNum;
return new Response<>(1, "Get Left Ticket of Internal Success", numOfLeftTicket);
}
private double getDirectProportion(HttpHeaders headers) {
String configName = "DirectTicketAllocationProportion";
HttpEntity requestEntity = new HttpEntity(null);
String config_service_url = getServiceUrl("ts-config-service");
ResponseEntity<Response<Config>> re = restTemplate.exchange(
config_service_url + "/api/v1/configservice/configs/" + configName,
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<Config>>() {
});
Response<Config> configValue = re.getBody();
SeatServiceImpl.LOGGER.info("[getDirectProportion][Configs is : {}]", configValue.getData().toString());
return Double.parseDouble(configValue.getData().getValue());
}
}
| 10,485 | 46.663636 | 179 |
java
|
train-ticket
|
train-ticket-master/ts-seat-service/src/test/java/seat/controller/SeatControllerTest.java
|
package seat.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.Seat;
import seat.service.SeatService;
@RunWith(JUnit4.class)
public class SeatControllerTest {
@InjectMocks
private SeatController seatController;
@Mock
private SeatService seatService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(seatController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/seatservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Seat Service ] !"));
}
@Test
public void testCreate() throws Exception {
Seat seatRequest = new Seat();
Mockito.when(seatService.distributeSeat(Mockito.any(Seat.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(seatRequest);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/seatservice/seats").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetLeftTicketOfInterval() throws Exception {
Seat seatRequest = new Seat();
Mockito.when(seatService.getLeftTicketOfInterval(Mockito.any(Seat.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(seatRequest);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/seatservice/seats/left_tickets").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 2,858 | 40.434783 | 171 |
java
|
train-ticket
|
train-ticket-master/ts-seat-service/src/test/java/seat/service/SeatServiceImplTest.java
|
package seat.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 java.util.ArrayList;
@RunWith(JUnit4.class)
public class SeatServiceImplTest {
@InjectMocks
private SeatServiceImpl seatServiceImpl;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testDistributeSeat1() {
Seat seat = new Seat();
seat.setTrainNumber("G");
seat.setSeatType(2);
seat.setStartStation("start_station");
seat.setDestStation("dest_station");
Route route = new Route();
route.setStations(new ArrayList<>());
Response<Route> response1 = new Response<>(null, null, route);
ResponseEntity<Response<Route>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Response<LeftTicketInfo> response2 = new Response<>();
ResponseEntity<Response<LeftTicketInfo>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
TrainType trainType = new TrainType();
trainType.setConfortClass(1);
Response<TrainType> response3 = new Response<>(null, null, trainType);
ResponseEntity<Response<TrainType>> re3 = new ResponseEntity<>(response3, 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);
Response result = seatServiceImpl.distributeSeat(seat, headers);
Assert.assertEquals("Use a new seat number!", result.getMsg());
}
@Test
public void testDistributeSeat2() {
Seat seat = new Seat();
seat.setTrainNumber("K");
seat.setSeatType(3);
seat.setStartStation("start_station");
seat.setDestStation("dest_station");
Route route = new Route();
route.setStations(new ArrayList<>());
Response<Route> response1 = new Response<>(null, null, route);
ResponseEntity<Response<Route>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Response<LeftTicketInfo> response2 = new Response<>();
ResponseEntity<Response<LeftTicketInfo>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
TrainType trainType = new TrainType();
trainType.setEconomyClass(1);
Response<TrainType> response3 = new Response<>(null, null, trainType);
ResponseEntity<Response<TrainType>> re3 = new ResponseEntity<>(response3, 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);
Response result = seatServiceImpl.distributeSeat(seat, headers);
Assert.assertEquals("Use a new seat number!", result.getMsg());
}
@Test
public void testGetLeftTicketOfInterval() {
Seat seat = new Seat();
seat.setTrainNumber("G");
seat.setSeatType(2);
seat.setStartStation("start_station");
seat.setDestStation("dest_station");
Route route = new Route();
route.setStations( new ArrayList<String>(){{ add("start_place"); }} );
Response<Route> response1 = new Response<>(null, null, route);
ResponseEntity<Response<Route>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Response<LeftTicketInfo> response2 = new Response<>();
ResponseEntity<Response<LeftTicketInfo>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
TrainType trainType = new TrainType();
trainType.setConfortClass(1);
Response<TrainType> response3 = new Response<>(null, null, trainType);
ResponseEntity<Response<TrainType>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
Config config = new Config();
config.setValue("0");
Response<Config> response4 = new Response<>(null, null, config);
ResponseEntity<Response<Config>> 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(re4);
Response result = seatServiceImpl.getLeftTicketOfInterval(seat, headers);
Assert.assertEquals(new Response<>(1, "Get Left Ticket of Internal Success", 1), result);
}
@Test
public void testGetLeftTicketOfInterva2() {
Seat seat = new Seat();
seat.setTrainNumber("K");
seat.setSeatType(3);
seat.setStartStation("start_station");
seat.setDestStation("dest_station");
Route route = new Route();
route.setStations( new ArrayList<String>(){{ add("start_place"); }} );
Response<Route> response1 = new Response<>(null, null, route);
ResponseEntity<Response<Route>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Response<LeftTicketInfo> response2 = new Response<>();
ResponseEntity<Response<LeftTicketInfo>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
TrainType trainType = new TrainType();
trainType.setEconomyClass(1);
Response<TrainType> response3 = new Response<>(null, null, trainType);
ResponseEntity<Response<TrainType>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
Config config = new Config();
config.setValue("0");
Response<Config> response4 = new Response<>(null, null, config);
ResponseEntity<Response<Config>> 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(re4);
Response result = seatServiceImpl.getLeftTicketOfInterval(seat, headers);
Assert.assertEquals(new Response<>(1, "Get Left Ticket of Internal Success", 1), result);
}
}
| 6,995 | 40.892216 | 102 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/SecurityApplication.java
|
package security;
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 SecurityApplication {
public static void main(String[] args) {
SpringApplication.run(SecurityApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,187 | 31.108108 | 75 |
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.