From 2dd00e9bfdc4809d58835e25fc98d1282daf1d15 Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 19 Oct 2023 16:18:12 +0800 Subject: [PATCH 001/163] feat: add base User entity class --- .../spring/data/entity/AbstractEntity.java | 54 ++++++++++ .../ntou/auction/spring/data/entity/User.java | 100 ++++++++++++++++++ 2 files changed, 154 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/AbstractEntity.java create mode 100644 src/main/java/ntou/auction/spring/data/entity/User.java diff --git a/src/main/java/ntou/auction/spring/data/entity/AbstractEntity.java b/src/main/java/ntou/auction/spring/data/entity/AbstractEntity.java new file mode 100644 index 0000000..ffd93c8 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/AbstractEntity.java @@ -0,0 +1,54 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.MappedSuperclass; +import jakarta.persistence.SequenceGenerator; +import jakarta.persistence.Version; + +@MappedSuperclass +public abstract class AbstractEntity { + + @Id + @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = + "idgenerator") + // The initial value is to account for data.sql demo data ids + @SequenceGenerator(name = "idgenerator", initialValue = 2) + private Long id; + + @Version + private int version; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public int getVersion() { + return version; + } + + @Override + public int hashCode() { + if (getId() != null) { + return getId().hashCode(); + } + return super.hashCode(); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof AbstractEntity other)) { + return false; // null or other class + } + + if (getId() != null) { + return getId().equals(other.getId()); + } + return super.equals(other); + } +} diff --git a/src/main/java/ntou/auction/spring/data/entity/User.java b/src/main/java/ntou/auction/spring/data/entity/User.java new file mode 100644 index 0000000..f14e3ae --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/User.java @@ -0,0 +1,100 @@ +package ntou.auction.spring.data.entity; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import ntou.auction.spring.data.Role; +import jakarta.persistence.Column; +import jakarta.persistence.ElementCollection; +import jakarta.persistence.Entity; +import jakarta.persistence.EnumType; +import jakarta.persistence.Enumerated; +import jakarta.persistence.FetchType; +import jakarta.persistence.Lob; +import jakarta.persistence.Table; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; +import org.springframework.security.core.GrantedAuthority; +import org.springframework.security.core.userdetails.UserDetails; + + +import java.util.Collection; +import java.util.Set; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +@Table(name = "user") +public class User extends AbstractEntity implements UserDetails { + + @NotNull + @Length(min = 1, max = 32) + @Column(unique = true) + private String username; + + @NotNull + @Length(min = 1, max = 32) + private String name; + + @NotNull + @JsonIgnore + private String hashedPassword; + + @NotNull + @Enumerated(EnumType.STRING) + @ElementCollection(fetch = FetchType.EAGER) + private Set roles; + + // if avatar is more than 5MB, need to modify column length + @Lob + @Column(length = 5242880) + private byte[] avatarImage; + + private String avatarImageName; + + @NotNull + @Email + @Column(unique = true) + private String email; + + private boolean enabled; + + private boolean isAccountNonExpired; + + private boolean isAccountNonLocked; + + private boolean isCredentialsNonExpired; + + @Override + public Collection getAuthorities() { + return null; + } + + @Override + public String getPassword() { + return this.hashedPassword; + } + + public boolean isAdmin() { + return roles.contains(Role.ADMIN); + } + + public void setAdmin(boolean bool) { + if (!bool && isAdmin()) { + roles.remove(Role.ADMIN); + } else if (bool && !isAdmin()) { + roles.add(Role.ADMIN); + } + } + + public @NotNull String getUsername() { + return username; + } + + public void setUsername(@NotNull String username) { + this.username = username; + } +} From 9019c1c8c297c248cdd75fc16c0ceef876369ba7 Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 19 Oct 2023 16:20:41 +0800 Subject: [PATCH 002/163] feat: add User Role entity class --- src/main/java/ntou/auction/spring/data/Role.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/Role.java diff --git a/src/main/java/ntou/auction/spring/data/Role.java b/src/main/java/ntou/auction/spring/data/Role.java new file mode 100644 index 0000000..4b6d60b --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/Role.java @@ -0,0 +1,5 @@ +package ntou.auction.spring.data; + +public enum Role { + USER, ADMIN +} From 0e2e0f02b1f8feff746e587f0945f19b8cbc2919 Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 19 Oct 2023 16:50:10 +0800 Subject: [PATCH 003/163] feat: Integrate MariaDB using Spring Data JPA for storing Users' Information. --- .../ntou/auction/spring/core/AppConfig.java | 36 ++++++++++ .../spring/data/service/UserRepository.java | 23 +++++++ .../spring/data/service/UserService.java | 67 +++++++++++++++++++ src/main/resources/application.properties | 36 ++++++++++ src/main/resources/data.sql | 9 +++ 5 files changed, 171 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/core/AppConfig.java create mode 100644 src/main/java/ntou/auction/spring/data/service/UserRepository.java create mode 100644 src/main/java/ntou/auction/spring/data/service/UserService.java create mode 100644 src/main/resources/application.properties create mode 100644 src/main/resources/data.sql diff --git a/src/main/java/ntou/auction/spring/core/AppConfig.java b/src/main/java/ntou/auction/spring/core/AppConfig.java new file mode 100644 index 0000000..78d0f9b --- /dev/null +++ b/src/main/java/ntou/auction/spring/core/AppConfig.java @@ -0,0 +1,36 @@ +package ntou.auction.spring.core; + +import lombok.Data; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.stereotype.Component; + + +@ConfigurationProperties(prefix = "app") +@Component +@Data +public class AppConfig { + + // default password encoder can be set by idForEncode + // BCrypt pbkdf2 argon2 + // @Value("{security.password.encoder:argon2}") + private String idForEncode; + + // only file size below 10MB can be uploaded + // you can modify this value, but the limit is 2047MB + // @Value("{upload.image.size:10}") + private int maxImageSizeInMegaBytes; + + // max 3 files can be uploaded + // you can modify this value + // @Value("{upload.image.number:3}") + private int maxImageFiles; + + // only file size below 3MB can be uploaded + // you can modify this value, but the limit is 2047MB + // @Value("{upload.avatar.size:3}") + private int maxAvatarSizeInMegaBytes; + + // The default image size limit for new sign-up users + private int newSignupImageSizeLimit; + +} \ No newline at end of file diff --git a/src/main/java/ntou/auction/spring/data/service/UserRepository.java b/src/main/java/ntou/auction/spring/data/service/UserRepository.java new file mode 100644 index 0000000..624c08e --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/UserRepository.java @@ -0,0 +1,23 @@ +package ntou.auction.spring.data.service; + +import ntou.auction.spring.data.entity.User; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface UserRepository extends JpaRepository, + JpaSpecificationExecutor { + + User findByUsername(String username); + + User findById(long id); + + @Query("select u from User u " + + "where u.email like :email") + List findAllByEmail(@Param("email") String email); +} diff --git a/src/main/java/ntou/auction/spring/data/service/UserService.java b/src/main/java/ntou/auction/spring/data/service/UserService.java new file mode 100644 index 0000000..92c6124 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/UserService.java @@ -0,0 +1,67 @@ +package ntou.auction.spring.data.service; +import ntou.auction.spring.data.entity.User; +import java.util.Optional; + +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; +import org.springframework.data.jpa.domain.Specification; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; + +@Service +public class UserService { + + private final UserRepository repository; + + private final PasswordEncoder passwordEncoder; + + public UserService(UserRepository repository, PasswordEncoder passwordEncoder) { + this.repository = repository; + this.passwordEncoder = passwordEncoder; + } + + public Optional get(Long id) { + return repository.findById(id); + } + + public User update(User entity) { + return repository.save(entity); + } + + public void delete(Long id) { + Optional maybeUser = repository.findById(id); + if (maybeUser.isPresent()) { + User user = maybeUser.get(); + repository.deleteById(id); + } + } + + public Page list(Pageable pageable) { + return repository.findAll(pageable); + } + + public Page list(Pageable pageable, Specification filter) { + return repository.findAll(filter, pageable); + } + + public int count() { + return (int) repository.count(); + } + + public void store(User user) { + repository.save(user); + } + + public PasswordEncoder getPasswordEncoder() { + return passwordEncoder; + } + + public boolean isUsernameNonExist(String username) { + return repository.findByUsername(username) == null; + } + + public boolean isEmailNonExist(String email) { + return repository.findAllByEmail(email).isEmpty(); + } + +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties new file mode 100644 index 0000000..5be0048 --- /dev/null +++ b/src/main/resources/application.properties @@ -0,0 +1,36 @@ +# port number +server.port=${PORT:8080} + +# mariadb database +# For persistent storage without dropping the database when the app stops, choose the "update" option. +# For development mode where the database is created when the app starts and dropped when it stops, choose the "create-drop" option. +spring.jpa.hibernate.ddl-auto=create-drop +spring.datasource.url=${NA_DB_URL} +spring.datasource.username=${NA_DB_USER} +spring.datasource.password=${NA_DB_PASSWORD} +spring.datasource.driver-class-name=org.mariadb.jdbc.Driver +spring.jpa.defer-datasource-initialization=true +spring.sql.init.mode=always + +# upload limit +# you need modify this value if you want upload bigger image +spring.servlet.multipart.max-file-size=30MB +spring.servlet.multipart.max-request-size=30MB +# only file size below 10MB can be uploaded +# you can modify this value, but the limit is 2047MB +app.maxImageSizeInMegaBytes=10 +# max 3 files can be uploaded +# you can modify this value +app.maxImageFiles=3 +# only file size below 3MB can be uploaded +# you can modify this value, but the limit is 5MB +app.maxAvatarSizeInMegaBytes=3 +# The default image size limit for new sign-up users +# you can modify this value +app.newSignupImageSizeLimit=30 +# security +# password encoder +# BCrypt pbkdf2 argon2 +app.idForEncode=argon2 + + diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql new file mode 100644 index 0000000..7539a4a --- /dev/null +++ b/src/main/resources/data.sql @@ -0,0 +1,9 @@ +insert into user (version, id, username, name, hashed_password, avatar_image, avatar_image_name, email, + enabled, is_account_non_expired, is_account_non_locked, is_credentials_non_expired) +values (1, '1', 'admin', 'admin', + '{argon2}$argon2id$v=19$m=16384,t=2,p=1$S9swkCEbXj5O8cwbZdyrtQ$4RkxTGl3xkEfm51P/gc3FORCysPStozAsm6smOnQR18', + null, null, 'admin@example.com', true, true, true, true); +insert into user_roles (user_id, roles) +values ('1', 'USER'); +insert into user_roles (user_id, roles) +values ('1', 'ADMIN'); \ No newline at end of file From 83e4352076d30ebb616106aad9ea424c195295dc Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 19 Oct 2023 16:54:12 +0800 Subject: [PATCH 004/163] feat: Introduce basic User Authentication with Spring Security. --- .../security/SecurityConfiguration.java | 95 +++++++++++++++++++ .../security/UserDetailsServiceImpl.java | 51 ++++++++++ 2 files changed, 146 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/security/SecurityConfiguration.java create mode 100644 src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java new file mode 100644 index 0000000..58e8c4f --- /dev/null +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -0,0 +1,95 @@ +package ntou.auction.spring.security; + +import ntou.auction.spring.core.AppConfig; +import ntou.auction.spring.data.Role; +import ntou.auction.spring.data.service.UserService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.http.HttpMethod; +import org.springframework.security.authentication.AuthenticationManager; +import org.springframework.security.authentication.ProviderManager; +import org.springframework.security.authentication.dao.DaoAuthenticationProvider; +import org.springframework.security.config.Customizer; +import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; +import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration; +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.configurers.AbstractHttpConfigurer; +import org.springframework.security.config.http.SessionCreationPolicy; +import org.springframework.security.crypto.argon2.Argon2PasswordEncoder; +import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; +import org.springframework.security.crypto.password.DelegatingPasswordEncoder; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.security.crypto.password.Pbkdf2PasswordEncoder; +import org.springframework.security.provisioning.JdbcUserDetailsManager; +import org.springframework.security.web.SecurityFilterChain; +import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; +import org.springframework.security.web.authentication.www.BasicAuthenticationFilter; +import org.springframework.security.web.util.matcher.AntPathRequestMatcher; + +import java.util.HashMap; +import java.util.Map; + +import static org.springframework.security.config.Customizer.withDefaults; + +@EnableWebSecurity +@Configuration +public class SecurityConfiguration { + private final AppConfig appConfig; + + private final UserDetailsServiceImpl userDetailsService; + + public SecurityConfiguration(AppConfig appConfig, UserDetailsServiceImpl userDetailsService) { + this.appConfig = appConfig; + this.userDetailsService = userDetailsService; + } + + @Bean + public PasswordEncoder passwordEncoder() { + // the following value can be changed to meet your need + // pbkdf2 + String secret = ""; + // byte + int pbkdf2SaltLength = 16; + int pbkdf2Iterations = 310000; + Pbkdf2PasswordEncoder.SecretKeyFactoryAlgorithm secretKeyFactoryAlgorithm = + Pbkdf2PasswordEncoder.SecretKeyFactoryAlgorithm.PBKDF2WithHmacSHA256; + // argon2 + int argon2SaltLength = 16; + int hashLength = 32; + int parallelism = 1; + int memory = 1 << 14; + int argon2Iterations = 2; + Map encoders = new HashMap<>(); + encoders.put("BCrypt", new BCryptPasswordEncoder()); + encoders.put("pbkdf2", new Pbkdf2PasswordEncoder(secret, + pbkdf2SaltLength, pbkdf2Iterations, secretKeyFactoryAlgorithm)); + encoders.put("pbkdf2@SpringSecurity_v5_8", + Pbkdf2PasswordEncoder.defaultsForSpringSecurity_v5_8()); + encoders.put("argon2", new Argon2PasswordEncoder(argon2SaltLength, + hashLength, parallelism, memory, argon2Iterations)); + encoders.put("argon2@SpringSecurity_v5_8", + Argon2PasswordEncoder.defaultsForSpringSecurity_v5_8()); + return new DelegatingPasswordEncoder(appConfig.getIdForEncode(), + encoders); + } + + @Bean + public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { + http + .csrf(AbstractHttpConfigurer::disable) + .authorizeHttpRequests(authorize -> authorize + .requestMatchers(HttpMethod.GET,"/users/**").authenticated() + .requestMatchers(HttpMethod.GET).permitAll() + .requestMatchers(HttpMethod.POST,"/users").permitAll() + .requestMatchers(HttpMethod.DELETE,"/users/**").hasRole(String.valueOf(Role.ADMIN)) + .anyRequest().authenticated()) + .sessionManagement((session) -> session + .sessionCreationPolicy(SessionCreationPolicy.STATELESS) + ) + .formLogin(withDefaults()); + return http.build(); + } + +} diff --git a/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java b/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java new file mode 100644 index 0000000..e87464f --- /dev/null +++ b/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java @@ -0,0 +1,51 @@ +package ntou.auction.spring.security; + +import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.UserRepository; + +import java.util.List; +import java.util.stream.Collectors; + +import org.springframework.security.core.GrantedAuthority; +import org.springframework.security.core.authority.SimpleGrantedAuthority; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.security.core.userdetails.UserDetailsService; +import org.springframework.security.core.userdetails.UsernameNotFoundException; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; + +@Service +public class UserDetailsServiceImpl implements UserDetailsService { + + private final UserRepository userRepository; + + public UserDetailsServiceImpl(UserRepository userRepository) { + this.userRepository = userRepository; + } + + private static List getAuthorities(User user) { + return user.getRoles().stream().map(role -> + new SimpleGrantedAuthority("ROLE_" + role)) + .collect(Collectors.toList()); + + } + + @Override + public UserDetails loadUserByUsername(String username) + throws UsernameNotFoundException { + User user = userRepository.findByUsername(username); + if (user != null) { + return new org.springframework.security.core.userdetails.User + (user.getUsername(), user.getHashedPassword(), + user.isEnabled(), + user.isAccountNonExpired(), + user.isCredentialsNonExpired(), + user.isAccountNonLocked() + , getAuthorities(user)); + } else { + throw new UsernameNotFoundException("No user present with " + + "username: " + username); + } + } + +} From 9cfbece3d616ba9b55bd225e702261c34eb23a8a Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 19 Oct 2023 16:56:17 +0800 Subject: [PATCH 005/163] feat: Introduce a simple Rest Controller for testing basic User Authentication. --- .../spring/controller/UserRestController.java | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/controller/UserRestController.java diff --git a/src/main/java/ntou/auction/spring/controller/UserRestController.java b/src/main/java/ntou/auction/spring/controller/UserRestController.java new file mode 100644 index 0000000..5f1ef57 --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/UserRestController.java @@ -0,0 +1,32 @@ +package ntou.auction.spring.controller; + +import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.UserService; +import org.springframework.data.domain.Page; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; +import java.util.Optional; + +@RestController +public class UserRestController { + + private final UserService userService; + + public UserRestController(UserService userService) { + this.userService = userService; + } + + + @GetMapping("/users") + Optional getById() { + return userService.get(1L); + } + + @GetMapping("admin") + public String helloAdmin() { + return "Hello Admin"; + } + +} From 95649ac330881f23747d299a99f2bf27a57add9e Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 21 Oct 2023 17:41:19 +0800 Subject: [PATCH 006/163] feat: Introduce JWT based User Authentication with Spring Security and jjwt. --- pom.xml | 17 ++++ .../auction/spring/security/AuthRequest.java | 18 +++++ .../auction/spring/security/AuthResponse.java | 8 ++ .../spring/security/JWTRequestFilter.java | 53 ++++++++++++ .../auction/spring/security/JWTService.java | 80 +++++++++++++++++++ .../security/SecurityConfiguration.java | 35 ++++---- 6 files changed, 190 insertions(+), 21 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/security/AuthRequest.java create mode 100644 src/main/java/ntou/auction/spring/security/AuthResponse.java create mode 100644 src/main/java/ntou/auction/spring/security/JWTRequestFilter.java create mode 100644 src/main/java/ntou/auction/spring/security/JWTService.java diff --git a/pom.xml b/pom.xml index 0d5aa0d..fb80fdb 100644 --- a/pom.xml +++ b/pom.xml @@ -61,6 +61,23 @@ bcprov-jdk18on 1.76 + + io.jsonwebtoken + jjwt-api + 0.12.3 + + + io.jsonwebtoken + jjwt-impl + 0.12.3 + runtime + + + io.jsonwebtoken + jjwt-jackson + 0.12.3 + runtime + org.springframework.boot spring-boot-starter-test diff --git a/src/main/java/ntou/auction/spring/security/AuthRequest.java b/src/main/java/ntou/auction/spring/security/AuthRequest.java new file mode 100644 index 0000000..06db39a --- /dev/null +++ b/src/main/java/ntou/auction/spring/security/AuthRequest.java @@ -0,0 +1,18 @@ +package ntou.auction.spring.security; + +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class AuthRequest { + + @NotNull + private String username; + + @NotNull + private String password; +} diff --git a/src/main/java/ntou/auction/spring/security/AuthResponse.java b/src/main/java/ntou/auction/spring/security/AuthResponse.java new file mode 100644 index 0000000..3d5ea58 --- /dev/null +++ b/src/main/java/ntou/auction/spring/security/AuthResponse.java @@ -0,0 +1,8 @@ +package ntou.auction.spring.security; + +import lombok.Data; + +@Data +public class AuthResponse { + private String accessToken; +} diff --git a/src/main/java/ntou/auction/spring/security/JWTRequestFilter.java b/src/main/java/ntou/auction/spring/security/JWTRequestFilter.java new file mode 100644 index 0000000..2009817 --- /dev/null +++ b/src/main/java/ntou/auction/spring/security/JWTRequestFilter.java @@ -0,0 +1,53 @@ +package ntou.auction.spring.security; + +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import org.springframework.http.HttpHeaders; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.security.web.authentication.WebAuthenticationDetailsSource; +import org.springframework.stereotype.Component; +import org.springframework.web.filter.OncePerRequestFilter; + +import java.io.IOException; + +@Component +public class JWTRequestFilter extends OncePerRequestFilter { + + private final UserDetailsServiceImpl userDetailsServiceImpl; + + public JWTRequestFilter(UserDetailsServiceImpl userDetailsServiceImpl) { + this.userDetailsServiceImpl = userDetailsServiceImpl; + } + + @Override + protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { + // look for AUTHORIZATION + final String header = request.getHeader(HttpHeaders.AUTHORIZATION); + if (header == null || !header.startsWith("Bearer ")) { + filterChain.doFilter(request, response); + return; + } + + final String token = header.substring(7); + final String username = JWTService.validateTokenAndGetUsername(token); + if (username == null) { + // validation failed or token expired + filterChain.doFilter(request, response); + return; + } + + // set user details on spring security context + final UserDetails userDetails = userDetailsServiceImpl.loadUserByUsername(username); + final UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken( + userDetails, null, userDetails.getAuthorities()); + authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); + SecurityContextHolder.getContext().setAuthentication(authentication); + + // continue with authenticated user + filterChain.doFilter(request, response); + } +} diff --git a/src/main/java/ntou/auction/spring/security/JWTService.java b/src/main/java/ntou/auction/spring/security/JWTService.java new file mode 100644 index 0000000..2a5e782 --- /dev/null +++ b/src/main/java/ntou/auction/spring/security/JWTService.java @@ -0,0 +1,80 @@ +package ntou.auction.spring.security; + +import io.jsonwebtoken.*; +import io.jsonwebtoken.io.Decoders; +import io.jsonwebtoken.security.Keys; +import org.springframework.security.authentication.AuthenticationManager; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.stereotype.Service; + +import javax.crypto.SecretKey; +import java.util.Date; +import java.util.UUID; + +@Service +public class JWTService { + + private static AuthenticationManager authenticationManager; + + public JWTService(AuthenticationManager authenticationManager) { + JWTService.authenticationManager = authenticationManager; + } + + // base64 encoded string + // privateKey + private static final String TOKEN_SECRET = "cuAihCz53DZRjZwbsGcZJ2Ai6At+T142uphtJMsk7iQ="; + + public static SecretKey getSigningKey() { + byte[] encodeKey = Decoders.BASE64.decode(JWTService.TOKEN_SECRET); + return Keys.hmacShaKeyFor(encodeKey); + + } + + public static String generateJWT(AuthRequest request) { + Authentication authentication = + new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword()); + authentication = authenticationManager.authenticate(authentication); + UserDetails userDetails = (UserDetails) authentication.getPrincipal(); + // millisecond + // 2 minute + long expireTime = 2 * 60 * 1000; + Date current = new Date(); + Date expiration = new Date(current.getTime() + expireTime); + + SecretKey secretKey = getSigningKey(); + return Jwts.builder() + .issuer("ntou.auction.spring") + .subject(userDetails.getUsername()) + .expiration(expiration) + .notBefore(current) + .issuedAt(current) + .id(UUID.randomUUID().toString()) + .signWith(secretKey) + .compact(); + } + + public static Jws parseJWT(String jwt) { + SecretKey secretKey = getSigningKey(); + + return Jwts.parser() + .verifyWith(secretKey) + .build() + .parseSignedClaims(jwt); + + } + + public static String validateTokenAndGetUsername(final String token) { + try { + Jws claims = JWTService.parseJWT(token); + System.out.println("解析成功" + claims.getPayload().getSubject()); + return claims.getPayload().getSubject(); + + } catch (JwtException ex) { + System.out.println("解析失敗:"); + return null; + } + } + +} diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 58e8c4f..2a4db35 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -2,16 +2,10 @@ import ntou.auction.spring.core.AppConfig; import ntou.auction.spring.data.Role; -import ntou.auction.spring.data.service.UserService; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.HttpMethod; import org.springframework.security.authentication.AuthenticationManager; -import org.springframework.security.authentication.ProviderManager; -import org.springframework.security.authentication.dao.DaoAuthenticationProvider; -import org.springframework.security.config.Customizer; -import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; @@ -22,27 +16,21 @@ import org.springframework.security.crypto.password.DelegatingPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.crypto.password.Pbkdf2PasswordEncoder; -import org.springframework.security.provisioning.JdbcUserDetailsManager; import org.springframework.security.web.SecurityFilterChain; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; -import org.springframework.security.web.authentication.www.BasicAuthenticationFilter; -import org.springframework.security.web.util.matcher.AntPathRequestMatcher; import java.util.HashMap; import java.util.Map; -import static org.springframework.security.config.Customizer.withDefaults; - @EnableWebSecurity @Configuration public class SecurityConfiguration { private final AppConfig appConfig; + private final JWTRequestFilter jwtRequestFilter; - private final UserDetailsServiceImpl userDetailsService; - - public SecurityConfiguration(AppConfig appConfig, UserDetailsServiceImpl userDetailsService) { + public SecurityConfiguration(AppConfig appConfig, JWTRequestFilter jwtRequestFilter) { this.appConfig = appConfig; - this.userDetailsService = userDetailsService; + this.jwtRequestFilter = jwtRequestFilter; } @Bean @@ -80,16 +68,21 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .csrf(AbstractHttpConfigurer::disable) .authorizeHttpRequests(authorize -> authorize - .requestMatchers(HttpMethod.GET,"/users/**").authenticated() - .requestMatchers(HttpMethod.GET).permitAll() - .requestMatchers(HttpMethod.POST,"/users").permitAll() - .requestMatchers(HttpMethod.DELETE,"/users/**").hasRole(String.valueOf(Role.ADMIN)) + .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/account/users/**").authenticated() + .requestMatchers(HttpMethod.POST, "/users").permitAll() + .requestMatchers(HttpMethod.DELETE, "/users/**").hasRole(String.valueOf(Role.ADMIN)) .anyRequest().authenticated()) + .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session .sessionCreationPolicy(SessionCreationPolicy.STATELESS) - ) - .formLogin(withDefaults()); + ); return http.build(); } + + @Bean + public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception { + return authenticationConfiguration.getAuthenticationManager(); + } } From 7836bebfae33636f04d38d2326dd273bf70aad21 Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 21 Oct 2023 17:48:03 +0800 Subject: [PATCH 007/163] feat: Introduce a Rest Controller for testing JWT User Authentication. --- .../spring/controller/AuthController.java | 29 ++++++++++++++ .../spring/controller/UserController.java | 38 +++++++++++++++++++ .../spring/data/service/UserIdentity.java | 29 ++++++++++++++ .../spring/data/service/UserService.java | 6 +++ 4 files changed, 102 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/controller/AuthController.java create mode 100644 src/main/java/ntou/auction/spring/controller/UserController.java create mode 100644 src/main/java/ntou/auction/spring/data/service/UserIdentity.java diff --git a/src/main/java/ntou/auction/spring/controller/AuthController.java b/src/main/java/ntou/auction/spring/controller/AuthController.java new file mode 100644 index 0000000..eed661d --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/AuthController.java @@ -0,0 +1,29 @@ +package ntou.auction.spring.controller; + +import jakarta.validation.Valid; +import ntou.auction.spring.security.AuthRequest; +import ntou.auction.spring.security.JWTService; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.Collections; +import java.util.Map; + +@RestController +@RequestMapping(value = "/api/v1/auth", produces = MediaType.APPLICATION_JSON_VALUE) +public class AuthController { + + + @PostMapping("/log-in") + public ResponseEntity> issueToken(@Valid @RequestBody AuthRequest request) { + String token = JWTService.generateJWT(request); + Map response = Collections.singletonMap("token", token); + + return ResponseEntity.ok(response); + } + +} diff --git a/src/main/java/ntou/auction/spring/controller/UserController.java b/src/main/java/ntou/auction/spring/controller/UserController.java new file mode 100644 index 0000000..b7e1cec --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/UserController.java @@ -0,0 +1,38 @@ +package ntou.auction.spring.controller; + +import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; +import org.springframework.http.MediaType; +import org.springframework.web.bind.annotation.*; + +@RestController +@RequestMapping(value = "/api/v1/account", produces = MediaType.APPLICATION_JSON_VALUE) +public class UserController { + private final UserService userService; + + private final UserIdentity userIdentity; + + public UserController(UserService userService, UserIdentity userIdentity) { + this.userService = userService; + this.userIdentity = userIdentity; + } + + // for admin usage + @GetMapping("/users/{username}") + @ResponseBody + User getByUser(@PathVariable String username) { + return userService.findByUsername(username); + } + + @GetMapping("/users") + @ResponseBody + User getUserProfileByJWT() { + return userService.findByUsername(userIdentity.getUsername()); + } + + @GetMapping("admin") + public String helloAdmin() { + return "Hello Admin"; + } +} diff --git a/src/main/java/ntou/auction/spring/data/service/UserIdentity.java b/src/main/java/ntou/auction/spring/data/service/UserIdentity.java new file mode 100644 index 0000000..43f2998 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/UserIdentity.java @@ -0,0 +1,29 @@ +package ntou.auction.spring.data.service; + +import ntou.auction.spring.data.Role; +import ntou.auction.spring.data.entity.User; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.stereotype.Component; + +@Component +public class UserIdentity { + private final User EMPTY_USER = new User(); + private final UserService userService; + + public UserIdentity(UserService userService) { + this.userService = userService; + } + + private User getCurrentUser() { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + UserDetails principal = (UserDetails) authentication.getPrincipal(); + return userService.findByUsername(principal.getUsername()).getRoles().contains(Role.USER) ? userService.findByUsername(principal.getUsername()) : EMPTY_USER; + } + + public String getUsername() { + return getCurrentUser().getUsername(); + } + +} \ No newline at end of file diff --git a/src/main/java/ntou/auction/spring/data/service/UserService.java b/src/main/java/ntou/auction/spring/data/service/UserService.java index 92c6124..2ebaa38 100644 --- a/src/main/java/ntou/auction/spring/data/service/UserService.java +++ b/src/main/java/ntou/auction/spring/data/service/UserService.java @@ -15,6 +15,8 @@ public class UserService { private final PasswordEncoder passwordEncoder; + + public UserService(UserRepository repository, PasswordEncoder passwordEncoder) { this.repository = repository; this.passwordEncoder = passwordEncoder; @@ -64,4 +66,8 @@ public boolean isEmailNonExist(String email) { return repository.findAllByEmail(email).isEmpty(); } + public User findByUsername(String userName){ + return repository.findByUsername(userName); + } + } From 1db5070aeac4e083b0f4fdf9ef7d0d9878c456b7 Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 21 Oct 2023 17:54:45 +0800 Subject: [PATCH 008/163] style: Clean up and remove unused code. --- .../spring/controller/UserRestController.java | 32 ------------------- .../security/UserDetailsServiceImpl.java | 1 - 2 files changed, 33 deletions(-) delete mode 100644 src/main/java/ntou/auction/spring/controller/UserRestController.java diff --git a/src/main/java/ntou/auction/spring/controller/UserRestController.java b/src/main/java/ntou/auction/spring/controller/UserRestController.java deleted file mode 100644 index 5f1ef57..0000000 --- a/src/main/java/ntou/auction/spring/controller/UserRestController.java +++ /dev/null @@ -1,32 +0,0 @@ -package ntou.auction.spring.controller; - -import ntou.auction.spring.data.entity.User; -import ntou.auction.spring.data.service.UserService; -import org.springframework.data.domain.Page; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.RestController; - -import java.util.List; -import java.util.Optional; - -@RestController -public class UserRestController { - - private final UserService userService; - - public UserRestController(UserService userService) { - this.userService = userService; - } - - - @GetMapping("/users") - Optional getById() { - return userService.get(1L); - } - - @GetMapping("admin") - public String helloAdmin() { - return "Hello Admin"; - } - -} diff --git a/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java b/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java index e87464f..45bc3f7 100644 --- a/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java +++ b/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java @@ -11,7 +11,6 @@ import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UsernameNotFoundException; -import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.stereotype.Service; @Service From 1d16beb0bca58258d668d9a4ddb833a8e935f1c8 Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 2 Nov 2023 22:09:45 +0800 Subject: [PATCH 009/163] fix: unblock preflight request for fixing CORS problem --- .../spring/controller/AuthController.java | 8 +++--- .../spring/controller/TestController.java | 26 +++++++++++++++++++ .../security/SecurityConfiguration.java | 4 +++ 3 files changed, 33 insertions(+), 5 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/controller/TestController.java diff --git a/src/main/java/ntou/auction/spring/controller/AuthController.java b/src/main/java/ntou/auction/spring/controller/AuthController.java index eed661d..362617c 100644 --- a/src/main/java/ntou/auction/spring/controller/AuthController.java +++ b/src/main/java/ntou/auction/spring/controller/AuthController.java @@ -1,20 +1,19 @@ package ntou.auction.spring.controller; +import jakarta.servlet.http.HttpServletResponse; import jakarta.validation.Valid; import ntou.auction.spring.security.AuthRequest; import ntou.auction.spring.security.JWTService; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.PostMapping; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.bind.annotation.*; import java.util.Collections; import java.util.Map; @RestController @RequestMapping(value = "/api/v1/auth", produces = MediaType.APPLICATION_JSON_VALUE) +@CrossOrigin(origins = "http://localhost:3000",allowCredentials = "true") public class AuthController { @@ -22,7 +21,6 @@ public class AuthController { public ResponseEntity> issueToken(@Valid @RequestBody AuthRequest request) { String token = JWTService.generateJWT(request); Map response = Collections.singletonMap("token", token); - return ResponseEntity.ok(response); } diff --git a/src/main/java/ntou/auction/spring/controller/TestController.java b/src/main/java/ntou/auction/spring/controller/TestController.java new file mode 100644 index 0000000..af98b19 --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/TestController.java @@ -0,0 +1,26 @@ +package ntou.auction.spring.controller; + +import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; +import org.springframework.http.MediaType; +import org.springframework.web.bind.annotation.*; + +@RestController +@RequestMapping(value = "/api/v1/test", produces = MediaType.APPLICATION_JSON_VALUE) +public class TestController { + private final UserService userService; + private final UserIdentity userIdentity; + + public TestController(UserService userService, UserIdentity userIdentity) { + this.userService = userService; + this.userIdentity = userIdentity; + } + + @GetMapping("/hello") + @ResponseBody + @CrossOrigin(origins = "http://localhost:3000") + public User helloAdmin() { + return userService.findByUsername("admin"); + } +} diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 2a4db35..4f25e55 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -18,6 +18,7 @@ import org.springframework.security.crypto.password.Pbkdf2PasswordEncoder; import org.springframework.security.web.SecurityFilterChain; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; +import org.springframework.web.cors.CorsUtils; import java.util.HashMap; import java.util.Map; @@ -67,8 +68,11 @@ public PasswordEncoder passwordEncoder() { public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .csrf(AbstractHttpConfigurer::disable) + .cors(AbstractHttpConfigurer::disable) .authorizeHttpRequests(authorize -> authorize + .requestMatchers( "/api/v1/test/**").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() + .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() .requestMatchers(HttpMethod.GET, "/api/v1/account/users/**").authenticated() .requestMatchers(HttpMethod.POST, "/users").permitAll() .requestMatchers(HttpMethod.DELETE, "/users/**").hasRole(String.valueOf(Role.ADMIN)) From 0bf5c9133b4ad4091cd9f662a0a460b040c83000 Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 4 Nov 2023 14:21:39 +0800 Subject: [PATCH 010/163] fix: fix CORS problem and modify security configuration. --- .../java/ntou/auction/spring/controller/UserController.java | 1 + .../ntou/auction/spring/security/SecurityConfiguration.java | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/UserController.java b/src/main/java/ntou/auction/spring/controller/UserController.java index b7e1cec..abd2d4b 100644 --- a/src/main/java/ntou/auction/spring/controller/UserController.java +++ b/src/main/java/ntou/auction/spring/controller/UserController.java @@ -8,6 +8,7 @@ @RestController @RequestMapping(value = "/api/v1/account", produces = MediaType.APPLICATION_JSON_VALUE) +@CrossOrigin(origins = "http://localhost:3000") public class UserController { private final UserService userService; diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 4f25e55..9b72925 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -74,8 +74,9 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() .requestMatchers(HttpMethod.GET, "/api/v1/account/users/**").authenticated() - .requestMatchers(HttpMethod.POST, "/users").permitAll() - .requestMatchers(HttpMethod.DELETE, "/users/**").hasRole(String.valueOf(Role.ADMIN)) + .requestMatchers(HttpMethod.GET, "/api/v1/account/users").authenticated() + .requestMatchers(HttpMethod.POST, "/api/v1/account/users").permitAll() + .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session From 9e5d22ced0311cc878db5b3d00b65f12ed948254 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 4 Nov 2023 15:52:43 +0800 Subject: [PATCH 011/163] feat: add base Product entity class --- .../auction/spring/data/entity/Product.java | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/Product.java diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java new file mode 100644 index 0000000..9a8ac62 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -0,0 +1,41 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.*; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +@Table(name = "product") +public class Product extends AbstractEntity { + + @NotNull + @Length(min = 1, max = 32) + private String productName; + + @NotNull + private Long price; + + @NotNull + private Boolean isFixedPrice; + + @NotNull + @Length(min = 1, max = 256) + private String productDescription; + + @NotNull + @Length(min = 1, max = 256) + private String productScale; + + // if avatar is more than 5MB, need to modify column length + @Lob + @Column(length = 5242880) + private byte[] productImage; + +} From ac4b5fe195968509a93cffa4558b9af06ab51abf Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 6 Nov 2023 21:13:57 +0800 Subject: [PATCH 012/163] feat: able to browse all product(default) --- .../spring/controller/ProductController.java | 39 +++++++++++ .../auction/spring/data/entity/Product.java | 1 - .../data/service/ProductRepository.java | 26 ++++++++ .../spring/data/service/ProductService.java | 64 +++++++++++++++++++ .../security/SecurityConfiguration.java | 1 + src/main/resources/data.sql | 8 ++- 6 files changed, 137 insertions(+), 2 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/controller/ProductController.java create mode 100644 src/main/java/ntou/auction/spring/data/service/ProductRepository.java create mode 100644 src/main/java/ntou/auction/spring/data/service/ProductService.java diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java new file mode 100644 index 0000000..b667f26 --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -0,0 +1,39 @@ +package ntou.auction.spring.controller; + +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.service.ProductService; +import org.springframework.http.MediaType; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping(value = "/api/v1/product", produces = MediaType.APPLICATION_JSON_VALUE) +@CrossOrigin(origins = "http://localhost:3000") +public class ProductController { + private final ProductService productService; + + + + public ProductController(ProductService productService) { + this.productService = productService; + } + + + @GetMapping("/products/{productName}") + @ResponseBody + Product getProductByProductName(@PathVariable String productName) { + return productService.findByProductName(productName); + } + + @GetMapping("/products") + @ResponseBody + List getProductProfile() { + return productService.list(); + } + + @GetMapping("admin") + public String helloAdmin() { + return "Hello Admin"; + } +} diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index 9a8ac62..96d45f4 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -1,7 +1,6 @@ package ntou.auction.spring.data.entity; import jakarta.persistence.*; -import jakarta.validation.constraints.Email; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java new file mode 100644 index 0000000..8e0344a --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -0,0 +1,26 @@ +package ntou.auction.spring.data.service; + +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.User; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface ProductRepository extends JpaRepository, + JpaSpecificationExecutor { + + Product findByProductName(String productName); + + Product findById(long id); + + @Query("select p from Product p " + + "where p.productName like :productName") //string-like + List findAllByProductName(@Param("productName") String productName); + + +} diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java new file mode 100644 index 0000000..709b345 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -0,0 +1,64 @@ +package ntou.auction.spring.data.service; +import ntou.auction.spring.data.entity.Product; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; +import org.springframework.data.jpa.domain.Specification; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; + +@Service +public class ProductService { + + private final ProductRepository repository; + + + public ProductService(ProductRepository repository) { + this.repository = repository; + } + + public Product get(String productName) { + return repository.findByProductName(productName); + } +/* + public Product update(Product entity) { + return repository.save(entity); + } + + public void delete(Long id) { + Optional maybeUser = repository.findById(id); + if (maybeUser.isPresent()) { + Product product = maybeUser.get(); + repository.deleteById(id); + } + } +*/ + public List list() { + return repository.findAll(); + } + + + + public int count() { + return (int) repository.count(); + } + + public void store(Product product) { + repository.save(product); + } + + + public boolean isProductNameNonExist(String productName) { + return repository.findByProductName(productName) == null; + } +/* + public boolean isEmailNonExist(String email) { + return repository.findAllByEmail(email).isEmpty(); + } +*/ + public Product findByProductName(String productName) { + return repository.findByProductName(productName); + } + +} diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 9b72925..b70b2f2 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -77,6 +77,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.GET, "/api/v1/account/users").authenticated() .requestMatchers(HttpMethod.POST, "/api/v1/account/users").permitAll() .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) + .requestMatchers( "/api/v1/product/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 7539a4a..774f24b 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -6,4 +6,10 @@ values (1, '1', 'admin', 'admin', insert into user_roles (user_id, roles) values ('1', 'USER'); insert into user_roles (user_id, roles) -values ('1', 'ADMIN'); \ No newline at end of file +values ('1', 'ADMIN'); + +insert into product (version,id,product_name, price,is_fixed_price,product_description,product_scale,product_image) +values (1,'1','Action-figure', 10000,true,'ggggg','kkkk',null); + +insert into product (version,id,product_name, price,is_fixed_price,product_description,product_scale,product_image) +values (2,'2','Action-figure', 10000,true,'ggggg','kkkkk',null); From f8e0fda698590558cfb840195543ea0c8644ba40 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 13 Nov 2023 00:21:27 +0800 Subject: [PATCH 013/163] feat: able to filter product by productName --- .../ntou/auction/spring/controller/ProductController.java | 2 +- .../auction/spring/data/service/ProductRepository.java | 7 +++---- .../ntou/auction/spring/data/service/ProductService.java | 4 ++-- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index b667f26..918de78 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -22,7 +22,7 @@ public ProductController(ProductService productService) { @GetMapping("/products/{productName}") @ResponseBody - Product getProductByProductName(@PathVariable String productName) { + List getProductByProductName(@PathVariable String productName) { return productService.findByProductName(productName); } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index 8e0344a..e431a7d 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -19,8 +19,7 @@ public interface ProductRepository extends JpaRepository, Product findById(long id); @Query("select p from Product p " + - "where p.productName like :productName") //string-like - List findAllByProductName(@Param("productName") String productName); - - + "where p.productName like %?1%") //string-like + List findAllByFuzzyProductName(@Param("productName") String productName); + // ?1:productName } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index 709b345..d5814cb 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -57,8 +57,8 @@ public boolean isEmailNonExist(String email) { return repository.findAllByEmail(email).isEmpty(); } */ - public Product findByProductName(String productName) { - return repository.findByProductName(productName); + public List findByProductName(String productName) { + return repository.findAllByFuzzyProductName(productName); } } From 686883bb79f770d69fbd6c36e852c4fd37796398 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 13 Nov 2023 00:23:06 +0800 Subject: [PATCH 014/163] fix: add 'productType' attribute to product entity --- .../auction/spring/data/entity/Product.java | 18 ++++++++++++++++-- src/main/resources/data.sql | 8 ++++---- 2 files changed, 20 insertions(+), 6 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index 96d45f4..7c1039f 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -18,6 +18,10 @@ public class Product extends AbstractEntity { @Length(min = 1, max = 32) private String productName; + @NotNull + @Length(min = 1, max = 32) + private String productType; + @NotNull private Long price; @@ -29,8 +33,18 @@ public class Product extends AbstractEntity { private String productDescription; @NotNull - @Length(min = 1, max = 256) - private String productScale; + @Length(min = 1, max = 32) + private String seller; + + //followings are non-isFixedPrice feature + + @NotNull + private Long upsetPrice; //lowest requested price + + + private Long currentPrice; + + // if avatar is more than 5MB, need to modify column length @Lob diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 774f24b..f629d82 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -8,8 +8,8 @@ values ('1', 'USER'); insert into user_roles (user_id, roles) values ('1', 'ADMIN'); -insert into product (version,id,product_name, price,is_fixed_price,product_description,product_scale,product_image) -values (1,'1','Action-figure', 10000,true,'ggggg','kkkk',null); +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,product_image,seller,upset_price,current_price) +values (1,'1','Action-figure','electronic',10000,true,'ggggg',null,'weichun',1000,1500); -insert into product (version,id,product_name, price,is_fixed_price,product_description,product_scale,product_image) -values (2,'2','Action-figure', 10000,true,'ggggg','kkkkk',null); +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,product_image,seller,upset_price,current_price) +values (2,'2','Tissue','daily need', 10000,true,'ggggg',null,'weichun',1000,1500); From e88ad9205186f26a4a783ff18c0676cc10468abc Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 15 Nov 2023 16:50:12 +0800 Subject: [PATCH 015/163] feat:able to search product by classification --- .../spring/controller/ProductController.java | 28 +++++++++++++------ .../data/service/ProductRepository.java | 7 ++++- .../spring/data/service/ProductService.java | 13 +++++---- 3 files changed, 33 insertions(+), 15 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 918de78..fcfa4ec 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -1,12 +1,14 @@ package ntou.auction.spring.controller; +import jakarta.validation.Valid; import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.ProductRequest; import ntou.auction.spring.data.service.ProductService; import org.springframework.http.MediaType; import org.springframework.web.bind.annotation.*; - import java.util.List; + @RestController @RequestMapping(value = "/api/v1/product", produces = MediaType.APPLICATION_JSON_VALUE) @CrossOrigin(origins = "http://localhost:3000") @@ -20,20 +22,30 @@ public ProductController(ProductService productService) { } - @GetMapping("/products/{productName}") + @GetMapping("/product") @ResponseBody - List getProductByProductName(@PathVariable String productName) { - return productService.findByProductName(productName); + public ListgetProductName(@Valid @RequestBody ProductRequest request) { + + long type =Integer.parseInt(request.getSearchType()); + + if(type == 1) { //find by name + String pn = request.getProductName(); + return productService.findByProductName(pn); + } + + else if(type == 2){ //find by classification + String pt = request.getProductType(); + return productService.findByProductClassification(pt); + } + return productService.list(); } + @GetMapping("/products") @ResponseBody List getProductProfile() { return productService.list(); } - @GetMapping("admin") - public String helloAdmin() { - return "Hello Admin"; - } + } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index e431a7d..ea5e5c5 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -1,7 +1,6 @@ package ntou.auction.spring.data.service; import ntou.auction.spring.data.entity.Product; -import ntou.auction.spring.data.entity.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.data.jpa.repository.Query; @@ -22,4 +21,10 @@ public interface ProductRepository extends JpaRepository, "where p.productName like %?1%") //string-like List findAllByFuzzyProductName(@Param("productName") String productName); // ?1:productName + + + @Query("select p from Product p where p.productType = ?1 ") + List findByProductType(@Param("productType") String productType); + + } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index d5814cb..dd7b7d4 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -6,7 +6,7 @@ import org.springframework.stereotype.Service; import java.util.List; -import java.util.Optional; + @Service public class ProductService { @@ -48,17 +48,18 @@ public void store(Product product) { repository.save(product); } - +/* public boolean isProductNameNonExist(String productName) { return repository.findByProductName(productName) == null; } -/* - public boolean isEmailNonExist(String email) { - return repository.findAllByEmail(email).isEmpty(); - } */ + public List findByProductName(String productName) { return repository.findAllByFuzzyProductName(productName); } + public List findByProductClassification(String productType){ + return repository.findByProductType(productType); + } + } From 1984ba73bdfbac3b6a5783d5dd970f7f1e9234bf Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 15 Nov 2023 16:51:33 +0800 Subject: [PATCH 016/163] feat:add new class to stand for FrontEnd data --- .../spring/data/entity/ProductRequest.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/ProductRequest.java diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java new file mode 100644 index 0000000..711d505 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java @@ -0,0 +1,27 @@ +package ntou.auction.spring.data.entity; + +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ProductRequest{ + + + @Length(min = 1, max = 32) + private String productName; + + + @Length(min = 1, max = 32) + private String productType; + + + private String searchType; + + + +} From 886c0033a134adcd7733aa769f2ec76b4e12664e Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 15 Nov 2023 16:52:11 +0800 Subject: [PATCH 017/163] fix:insert new testcase , debug --- .../ntou/auction/spring/security/SecurityConfiguration.java | 2 +- src/main/resources/data.sql | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index b70b2f2..088f98c 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -77,7 +77,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.GET, "/api/v1/account/users").authenticated() .requestMatchers(HttpMethod.POST, "/api/v1/account/users").permitAll() .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) - .requestMatchers( "/api/v1/product/**").permitAll() + .requestMatchers( HttpMethod.GET,"/api/v1/product/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index f629d82..51e2fa5 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -12,4 +12,7 @@ insert into product (version,id,product_name,product_type, price,is_fixed_price, values (1,'1','Action-figure','electronic',10000,true,'ggggg',null,'weichun',1000,1500); insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,product_image,seller,upset_price,current_price) -values (2,'2','Tissue','daily need', 10000,true,'ggggg',null,'weichun',1000,1500); +values (2,'2','衛生紙','daily need', 10000,true,'ggggg',null,'weichun',1000,1500); + +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,product_image,seller,upset_price,current_price) +values (3,'3','action figure','electronic',10000,true,'ggggg',null,'weichun',1000,1500); \ No newline at end of file From 91a6c139af8ae851ac4806b8b9163d7bc8c2a44b Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 15 Nov 2023 19:10:45 +0800 Subject: [PATCH 018/163] feat: Implement a REST Controller for User Signup. --- .../spring/controller/AuthController.java | 42 +++++++++++++++++-- .../security/SecurityConfiguration.java | 1 + .../spring/security/SignupRequest.java | 37 ++++++++++++++++ 3 files changed, 76 insertions(+), 4 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/security/SignupRequest.java diff --git a/src/main/java/ntou/auction/spring/controller/AuthController.java b/src/main/java/ntou/auction/spring/controller/AuthController.java index 362617c..b9b54c4 100644 --- a/src/main/java/ntou/auction/spring/controller/AuthController.java +++ b/src/main/java/ntou/auction/spring/controller/AuthController.java @@ -1,21 +1,30 @@ package ntou.auction.spring.controller; -import jakarta.servlet.http.HttpServletResponse; import jakarta.validation.Valid; +import ntou.auction.spring.data.Role; +import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.UserService; import ntou.auction.spring.security.AuthRequest; import ntou.auction.spring.security.JWTService; +import ntou.auction.spring.security.SignupRequest; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; +import org.springframework.validation.Errors; import org.springframework.web.bind.annotation.*; -import java.util.Collections; -import java.util.Map; +import java.util.*; @RestController @RequestMapping(value = "/api/v1/auth", produces = MediaType.APPLICATION_JSON_VALUE) -@CrossOrigin(origins = "http://localhost:3000",allowCredentials = "true") +@CrossOrigin(origins = "http://localhost:3000", allowCredentials = "true") public class AuthController { + private final UserService userService; + + public AuthController(UserService userService) { + this.userService = userService; + } + @PostMapping("/log-in") public ResponseEntity> issueToken(@Valid @RequestBody AuthRequest request) { @@ -24,4 +33,29 @@ public ResponseEntity> issueToken(@Valid @RequestBody AuthRe return ResponseEntity.ok(response); } + @PostMapping("/sign-up") + public ResponseEntity signUp(@Valid @RequestBody SignupRequest request, Errors errors) { + String response = "Success"; + User newUser = new User(); + HashSet roles = new HashSet<>(); + roles.add(Role.USER); + newUser.setEmail(request.getEmail()); + newUser.setUsername(request.getUsername()); + newUser.setName(request.getName()); + newUser.setHashedPassword(userService.getPasswordEncoder().encode(request.getPassword())); + newUser.setRoles(roles); + newUser.setEnabled(true); + newUser.setAccountNonExpired(true); + newUser.setAccountNonLocked(true); + newUser.setCredentialsNonExpired(true); + if(!userService.isUsernameNonExist(request.getUsername())){ + return ResponseEntity.badRequest().body("Username duplicated"); + } + if(!userService.isEmailNonExist(request.getEmail())){ + return ResponseEntity.badRequest().body("Email duplicated"); + } + userService.store(newUser); + return ResponseEntity.ok(response); + } + } diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 9b72925..733083e 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -72,6 +72,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .authorizeHttpRequests(authorize -> authorize .requestMatchers( "/api/v1/test/**").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() + .requestMatchers(HttpMethod.POST, "/api/v1/auth/sign-up").permitAll() .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() .requestMatchers(HttpMethod.GET, "/api/v1/account/users/**").authenticated() .requestMatchers(HttpMethod.GET, "/api/v1/account/users").authenticated() diff --git a/src/main/java/ntou/auction/spring/security/SignupRequest.java b/src/main/java/ntou/auction/spring/security/SignupRequest.java new file mode 100644 index 0000000..4b9b7b4 --- /dev/null +++ b/src/main/java/ntou/auction/spring/security/SignupRequest.java @@ -0,0 +1,37 @@ +package ntou.auction.spring.security; + +import jakarta.persistence.*; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class SignupRequest { + @NotBlank(message = "帳號不可為空!") + @Length(min = 1, max = 32, message = "帳號長度限制為1~32") + @Column(unique = true) + private String username; + + @NotNull(message = "暱稱不可為空!") + @Length(min = 1, max = 32) + private String name; + + @NotBlank(message = "密碼不可為空!") + private String password; + + // if avatar is more than 5MB, need to modify column length + @Lob + @Column(length = 5242880) + private byte[] avatarImage; + + @NotBlank(message = "電子信箱不可為空!") + @Email(message = "電子信箱格式錯誤!") + @Column(unique = true) + private String email; +} From deb8f829204c3fb83750b50983627e0f9734b390 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 15 Nov 2023 19:13:37 +0800 Subject: [PATCH 019/163] fix: Correct data.sql: Change id type to long instead of string. --- src/main/resources/data.sql | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 7539a4a..a98d2a1 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -1,9 +1,9 @@ insert into user (version, id, username, name, hashed_password, avatar_image, avatar_image_name, email, enabled, is_account_non_expired, is_account_non_locked, is_credentials_non_expired) -values (1, '1', 'admin', 'admin', +values (1, 1, 'admin', 'admin', '{argon2}$argon2id$v=19$m=16384,t=2,p=1$S9swkCEbXj5O8cwbZdyrtQ$4RkxTGl3xkEfm51P/gc3FORCysPStozAsm6smOnQR18', null, null, 'admin@example.com', true, true, true, true); insert into user_roles (user_id, roles) -values ('1', 'USER'); +values (1, 'USER'); insert into user_roles (user_id, roles) -values ('1', 'ADMIN'); \ No newline at end of file +values (1, 'ADMIN'); \ No newline at end of file From 4c0e74fdb5cb93ad6c459e6e968375fa61922053 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 15 Nov 2023 19:16:17 +0800 Subject: [PATCH 020/163] fix: Enhance security: Replace @NotNull with @NotBlank for username and email validation. --- src/main/java/ntou/auction/spring/data/entity/User.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/User.java b/src/main/java/ntou/auction/spring/data/entity/User.java index f14e3ae..fabf0c6 100644 --- a/src/main/java/ntou/auction/spring/data/entity/User.java +++ b/src/main/java/ntou/auction/spring/data/entity/User.java @@ -1,6 +1,7 @@ package ntou.auction.spring.data.entity; import com.fasterxml.jackson.annotation.JsonIgnore; +import jakarta.validation.constraints.NotBlank; import ntou.auction.spring.data.Role; import jakarta.persistence.Column; import jakarta.persistence.ElementCollection; @@ -30,7 +31,7 @@ @Table(name = "user") public class User extends AbstractEntity implements UserDetails { - @NotNull + @NotBlank @Length(min = 1, max = 32) @Column(unique = true) private String username; @@ -39,7 +40,7 @@ public class User extends AbstractEntity implements UserDetails { @Length(min = 1, max = 32) private String name; - @NotNull + @NotBlank @JsonIgnore private String hashedPassword; @@ -55,7 +56,7 @@ public class User extends AbstractEntity implements UserDetails { private String avatarImageName; - @NotNull + @NotBlank @Email @Column(unique = true) private String email; From 6e91253c7c2ce0c71ffafffd6fa937b833a19797 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 15 Nov 2023 22:43:54 +0800 Subject: [PATCH 021/163] feat: Introduce a REST Controller for User Signup with error handling. --- .../spring/controller/AuthController.java | 25 +++++++++++++++---- .../RestResponseEntityExceptionHandler.java | 24 ++++++++++++++++++ .../ntou/auction/spring/data/entity/User.java | 14 ++++------- .../spring/security/SignupRequest.java | 12 ++++----- 4 files changed, 54 insertions(+), 21 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java diff --git a/src/main/java/ntou/auction/spring/controller/AuthController.java b/src/main/java/ntou/auction/spring/controller/AuthController.java index b9b54c4..0a34661 100644 --- a/src/main/java/ntou/auction/spring/controller/AuthController.java +++ b/src/main/java/ntou/auction/spring/controller/AuthController.java @@ -34,14 +34,26 @@ public ResponseEntity> issueToken(@Valid @RequestBody AuthRe } @PostMapping("/sign-up") - public ResponseEntity signUp(@Valid @RequestBody SignupRequest request, Errors errors) { - String response = "Success"; + public ResponseEntity> signUp(@Valid @RequestBody SignupRequest request, Errors errors) { + String successMessage = "Success"; + String usernameDuplicatedMessage = "輸入的帳號已被其他人使用，請使用別的帳號註冊!"; + String emailDuplicatedMessage = "輸入的電子信箱已被其他人使用，請使用別的信箱註冊!"; + String emailAndUsernameDuplicatedMessage = "輸入的帳號及電子信箱皆已被其他人使用，請重新註冊!"; + String passwordMessage = "至少需要8位密碼，且不超過128位"; + Map successResponse = Collections.singletonMap("message", successMessage); + Map usernameDuplicatedResponse = Collections.singletonMap("message", usernameDuplicatedMessage); + Map emailDuplicatedResponse = Collections.singletonMap("message", emailDuplicatedMessage); + Map emailAndUsernameDuplicatedResponse = Collections.singletonMap("message", emailAndUsernameDuplicatedMessage); + Map passwordResponse = Collections.singletonMap("message", passwordMessage); User newUser = new User(); HashSet roles = new HashSet<>(); roles.add(Role.USER); newUser.setEmail(request.getEmail()); newUser.setUsername(request.getUsername()); newUser.setName(request.getName()); + if(request.getPassword().length() < 8 || request.getPassword().length() > 128){ + return ResponseEntity.badRequest().body(passwordResponse); + } newUser.setHashedPassword(userService.getPasswordEncoder().encode(request.getPassword())); newUser.setRoles(roles); newUser.setEnabled(true); @@ -49,13 +61,16 @@ public ResponseEntity signUp(@Valid @RequestBody SignupRequest request, newUser.setAccountNonLocked(true); newUser.setCredentialsNonExpired(true); if(!userService.isUsernameNonExist(request.getUsername())){ - return ResponseEntity.badRequest().body("Username duplicated"); + if(!userService.isEmailNonExist(request.getEmail())){ + return ResponseEntity.badRequest().body(emailAndUsernameDuplicatedResponse); + } + return ResponseEntity.badRequest().body(usernameDuplicatedResponse); } if(!userService.isEmailNonExist(request.getEmail())){ - return ResponseEntity.badRequest().body("Email duplicated"); + return ResponseEntity.badRequest().body(emailDuplicatedResponse); } userService.store(newUser); - return ResponseEntity.ok(response); + return ResponseEntity.ok(successResponse); } } diff --git a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java new file mode 100644 index 0000000..1bc465c --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java @@ -0,0 +1,24 @@ +package ntou.auction.spring.controller; + +import jakarta.validation.ConstraintViolation; +import jakarta.validation.ConstraintViolationException; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.ControllerAdvice; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; + +import java.util.Collections; +import java.util.Map; + +@ControllerAdvice +public class RestResponseEntityExceptionHandler + extends ResponseEntityExceptionHandler { + + @ExceptionHandler(ConstraintViolationException.class) + public ResponseEntity> handleConstraintViolationException(ConstraintViolationException ex) { + ConstraintViolation constraintViolation = ex.getConstraintViolations().iterator().next(); + String errorMessage = constraintViolation.getMessage(); + Map response = Collections.singletonMap("message", errorMessage); + return ResponseEntity.badRequest().body(response); + } +} \ No newline at end of file diff --git a/src/main/java/ntou/auction/spring/data/entity/User.java b/src/main/java/ntou/auction/spring/data/entity/User.java index fabf0c6..313cedf 100644 --- a/src/main/java/ntou/auction/spring/data/entity/User.java +++ b/src/main/java/ntou/auction/spring/data/entity/User.java @@ -1,6 +1,5 @@ package ntou.auction.spring.data.entity; -import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.validation.constraints.NotBlank; import ntou.auction.spring.data.Role; import jakarta.persistence.Column; @@ -31,17 +30,14 @@ @Table(name = "user") public class User extends AbstractEntity implements UserDetails { - @NotBlank - @Length(min = 1, max = 32) + @Length(min = 1, max = 34, message = "帳號長度限制為1~32個字元!") @Column(unique = true) private String username; - @NotNull - @Length(min = 1, max = 32) + @Length(min = 1, max = 34, message = "暱稱長度限制為1~32個字元!") private String name; - @NotBlank - @JsonIgnore + @NotBlank(message = "密碼不可為空!") private String hashedPassword; @NotNull @@ -56,8 +52,8 @@ public class User extends AbstractEntity implements UserDetails { private String avatarImageName; - @NotBlank - @Email + @NotBlank(message = "電子信箱不可為空!") + @Email(message = "電子信箱格式錯誤!") @Column(unique = true) private String email; diff --git a/src/main/java/ntou/auction/spring/security/SignupRequest.java b/src/main/java/ntou/auction/spring/security/SignupRequest.java index 4b9b7b4..075fe09 100644 --- a/src/main/java/ntou/auction/spring/security/SignupRequest.java +++ b/src/main/java/ntou/auction/spring/security/SignupRequest.java @@ -3,7 +3,6 @@ import jakarta.persistence.*; import jakarta.validation.constraints.Email; import jakarta.validation.constraints.NotBlank; -import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @@ -13,21 +12,20 @@ @NoArgsConstructor @AllArgsConstructor public class SignupRequest { - @NotBlank(message = "帳號不可為空!") - @Length(min = 1, max = 32, message = "帳號長度限制為1~32") + + @Length(min = 1, max = 34, message = "帳號長度限制為1~32個字元!") @Column(unique = true) private String username; - @NotNull(message = "暱稱不可為空!") - @Length(min = 1, max = 32) + @Length(min = 1, max = 34, message = "暱稱長度限制為1~32個字元!") private String name; - @NotBlank(message = "密碼不可為空!") + @Length(min = 8, max = 130, message = "密碼長度限制為8~128位!") private String password; // if avatar is more than 5MB, need to modify column length @Lob - @Column(length = 5242880) + @Column(length = 5243000) private byte[] avatarImage; @NotBlank(message = "電子信箱不可為空!") From 65f74084f23c3b05f04ab0a918bbe639ae82aab3 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 15 Nov 2023 22:47:26 +0800 Subject: [PATCH 022/163] style: Clean up and remove unused code. --- .../spring/controller/AuthController.java | 3 +-- .../spring/controller/TestController.java | 26 ------------------- .../spring/controller/UserController.java | 6 ++--- 3 files changed, 3 insertions(+), 32 deletions(-) delete mode 100644 src/main/java/ntou/auction/spring/controller/TestController.java diff --git a/src/main/java/ntou/auction/spring/controller/AuthController.java b/src/main/java/ntou/auction/spring/controller/AuthController.java index 0a34661..c32b867 100644 --- a/src/main/java/ntou/auction/spring/controller/AuthController.java +++ b/src/main/java/ntou/auction/spring/controller/AuthController.java @@ -9,7 +9,6 @@ import ntou.auction.spring.security.SignupRequest; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; -import org.springframework.validation.Errors; import org.springframework.web.bind.annotation.*; import java.util.*; @@ -34,7 +33,7 @@ public ResponseEntity> issueToken(@Valid @RequestBody AuthRe } @PostMapping("/sign-up") - public ResponseEntity> signUp(@Valid @RequestBody SignupRequest request, Errors errors) { + public ResponseEntity> signUp(@Valid @RequestBody SignupRequest request) { String successMessage = "Success"; String usernameDuplicatedMessage = "輸入的帳號已被其他人使用，請使用別的帳號註冊!"; String emailDuplicatedMessage = "輸入的電子信箱已被其他人使用，請使用別的信箱註冊!"; diff --git a/src/main/java/ntou/auction/spring/controller/TestController.java b/src/main/java/ntou/auction/spring/controller/TestController.java deleted file mode 100644 index af98b19..0000000 --- a/src/main/java/ntou/auction/spring/controller/TestController.java +++ /dev/null @@ -1,26 +0,0 @@ -package ntou.auction.spring.controller; - -import ntou.auction.spring.data.entity.User; -import ntou.auction.spring.data.service.UserIdentity; -import ntou.auction.spring.data.service.UserService; -import org.springframework.http.MediaType; -import org.springframework.web.bind.annotation.*; - -@RestController -@RequestMapping(value = "/api/v1/test", produces = MediaType.APPLICATION_JSON_VALUE) -public class TestController { - private final UserService userService; - private final UserIdentity userIdentity; - - public TestController(UserService userService, UserIdentity userIdentity) { - this.userService = userService; - this.userIdentity = userIdentity; - } - - @GetMapping("/hello") - @ResponseBody - @CrossOrigin(origins = "http://localhost:3000") - public User helloAdmin() { - return userService.findByUsername("admin"); - } -} diff --git a/src/main/java/ntou/auction/spring/controller/UserController.java b/src/main/java/ntou/auction/spring/controller/UserController.java index abd2d4b..f7fe881 100644 --- a/src/main/java/ntou/auction/spring/controller/UserController.java +++ b/src/main/java/ntou/auction/spring/controller/UserController.java @@ -20,11 +20,13 @@ public UserController(UserService userService, UserIdentity userIdentity) { } // for admin usage + /* @GetMapping("/users/{username}") @ResponseBody User getByUser(@PathVariable String username) { return userService.findByUsername(username); } + */ @GetMapping("/users") @ResponseBody @@ -32,8 +34,4 @@ User getUserProfileByJWT() { return userService.findByUsername(userIdentity.getUsername()); } - @GetMapping("admin") - public String helloAdmin() { - return "Hello Admin"; - } } From e403dd458d5d3392018a647e512722b163bac1a7 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 15 Nov 2023 23:41:05 +0800 Subject: [PATCH 023/163] fix: Override handleMethodArgumentNotValid method to display user-friendly error messages. --- .../RestResponseEntityExceptionHandler.java | 27 ++++++++++++++++--- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java index 1bc465c..99edb06 100644 --- a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java +++ b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java @@ -2,17 +2,22 @@ import jakarta.validation.ConstraintViolation; import jakarta.validation.ConstraintViolationException; +import org.apache.tomcat.util.buf.StringUtils; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatusCode; import org.springframework.http.ResponseEntity; +import org.springframework.validation.FieldError; +import org.springframework.validation.ObjectError; +import org.springframework.web.bind.MethodArgumentNotValidException; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.context.request.WebRequest; import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; -import java.util.Collections; -import java.util.Map; +import java.util.*; @ControllerAdvice -public class RestResponseEntityExceptionHandler - extends ResponseEntityExceptionHandler { +public class RestResponseEntityExceptionHandler extends ResponseEntityExceptionHandler { @ExceptionHandler(ConstraintViolationException.class) public ResponseEntity> handleConstraintViolationException(ConstraintViolationException ex) { @@ -21,4 +26,18 @@ public ResponseEntity> handleConstraintViolationException(Co Map response = Collections.singletonMap("message", errorMessage); return ResponseEntity.badRequest().body(response); } + + @Override + protected ResponseEntity handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) { + List errors = new ArrayList<>(); + for (FieldError error : ex.getBindingResult().getFieldErrors()) { + errors.add(error.getDefaultMessage()); + } + for (ObjectError error : ex.getBindingResult().getGlobalErrors()) { + errors.add(error.getDefaultMessage()); + } + Map response = Collections.singletonMap("message", StringUtils.join(errors,' ')); + return handleExceptionInternal( + ex, response, headers, status, request); + } } \ No newline at end of file From ebb5b135045b13537df15fe81e9cb6f32c2cfec5 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Thu, 16 Nov 2023 18:22:42 +0800 Subject: [PATCH 024/163] fix: Change product image to Base64 type --- src/main/resources/data.sql | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 51e2fa5..eb57154 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -1,18 +1,19 @@ insert into user (version, id, username, name, hashed_password, avatar_image, avatar_image_name, email, enabled, is_account_non_expired, is_account_non_locked, is_credentials_non_expired) -values (1, '1', 'admin', 'admin', +values (1, 1, 'admin', 'admin', '{argon2}$argon2id$v=19$m=16384,t=2,p=1$S9swkCEbXj5O8cwbZdyrtQ$4RkxTGl3xkEfm51P/gc3FORCysPStozAsm6smOnQR18', null, null, 'admin@example.com', true, true, true, true); insert into user_roles (user_id, roles) -values ('1', 'USER'); +values (1, 'USER'); insert into user_roles (user_id, roles) -values ('1', 'ADMIN'); +values (1, 'ADMIN'); -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,product_image,seller,upset_price,current_price) -values (1,'1','Action-figure','electronic',10000,true,'ggggg',null,'weichun',1000,1500); +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) +values (1,1,'IPhone13','electronic',10000,true,'ggggg','weichun',1000,1500,'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'); -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,product_image,seller,upset_price,current_price) -values (2,'2','衛生紙','daily need', 10000,true,'ggggg',null,'weichun',1000,1500); -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,product_image,seller,upset_price,current_price) -values (3,'3','action figure','electronic',10000,true,'ggggg',null,'weichun',1000,1500); \ No newline at end of file +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) +values (2,2,'衛生紙','Daily need', 10000,true,'ggggg','weichun',1000,1500,'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'); + +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) +values (3,3,'action figure','Stationary',10000,true,'ggggg','weichun',1000,1500,'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'); From 8eff5feb5c5b0b7826a8e83bc4ca76a31a2ddfa7 Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 16 Nov 2023 20:30:55 +0800 Subject: [PATCH 025/163] fix: display user-friendly error messages. --- .../java/ntou/auction/spring/controller/AuthController.java | 2 +- .../controller/RestResponseEntityExceptionHandler.java | 2 +- src/main/java/ntou/auction/spring/data/entity/User.java | 4 ++-- .../java/ntou/auction/spring/security/SignupRequest.java | 6 +++--- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/AuthController.java b/src/main/java/ntou/auction/spring/controller/AuthController.java index c32b867..a0c848d 100644 --- a/src/main/java/ntou/auction/spring/controller/AuthController.java +++ b/src/main/java/ntou/auction/spring/controller/AuthController.java @@ -34,7 +34,7 @@ public ResponseEntity> issueToken(@Valid @RequestBody AuthRe @PostMapping("/sign-up") public ResponseEntity> signUp(@Valid @RequestBody SignupRequest request) { - String successMessage = "Success"; + String successMessage = "成功註冊"; String usernameDuplicatedMessage = "輸入的帳號已被其他人使用，請使用別的帳號註冊!"; String emailDuplicatedMessage = "輸入的電子信箱已被其他人使用，請使用別的信箱註冊!"; String emailAndUsernameDuplicatedMessage = "輸入的帳號及電子信箱皆已被其他人使用，請重新註冊!"; diff --git a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java index 99edb06..aaea094 100644 --- a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java +++ b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java @@ -36,7 +36,7 @@ protected ResponseEntity handleMethodArgumentNotValid(MethodArgumentNotV for (ObjectError error : ex.getBindingResult().getGlobalErrors()) { errors.add(error.getDefaultMessage()); } - Map response = Collections.singletonMap("message", StringUtils.join(errors,' ')); + Map response = Collections.singletonMap("message", StringUtils.join(errors,'\n')); return handleExceptionInternal( ex, response, headers, status, request); } diff --git a/src/main/java/ntou/auction/spring/data/entity/User.java b/src/main/java/ntou/auction/spring/data/entity/User.java index 313cedf..4b60e2e 100644 --- a/src/main/java/ntou/auction/spring/data/entity/User.java +++ b/src/main/java/ntou/auction/spring/data/entity/User.java @@ -30,11 +30,11 @@ @Table(name = "user") public class User extends AbstractEntity implements UserDetails { - @Length(min = 1, max = 34, message = "帳號長度限制為1~32個字元!") + @Length(min = 1, max = 128, message = "帳號長度限制為1~32位!") @Column(unique = true) private String username; - @Length(min = 1, max = 34, message = "暱稱長度限制為1~32個字元!") + @Length(min = 1, max = 128, message = "暱稱長度限制為1~32位!") private String name; @NotBlank(message = "密碼不可為空!") diff --git a/src/main/java/ntou/auction/spring/security/SignupRequest.java b/src/main/java/ntou/auction/spring/security/SignupRequest.java index 075fe09..ed10983 100644 --- a/src/main/java/ntou/auction/spring/security/SignupRequest.java +++ b/src/main/java/ntou/auction/spring/security/SignupRequest.java @@ -13,14 +13,14 @@ @AllArgsConstructor public class SignupRequest { - @Length(min = 1, max = 34, message = "帳號長度限制為1~32個字元!") + @Length(min = 1, max = 128, message = "帳號長度限制為1~32位!") @Column(unique = true) private String username; - @Length(min = 1, max = 34, message = "暱稱長度限制為1~32個字元!") + @Length(min = 1, max = 128, message = "暱稱長度限制為1~32位!") private String name; - @Length(min = 8, max = 130, message = "密碼長度限制為8~128位!") + @Length(min = 8, max = 512, message = "密碼長度限制為8~128位!") private String password; // if avatar is more than 5MB, need to modify column length From 1e0864645c3825e43bbaf8e044c5d2ee2cc459cd Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 17 Nov 2023 00:52:49 +0800 Subject: [PATCH 026/163] feat: able to search by ID to see the product detail --- .../ntou/auction/spring/controller/ProductController.java | 6 ++++++ .../ntou/auction/spring/data/service/ProductService.java | 4 +++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index fcfa4ec..cf3ebe8 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -47,5 +47,11 @@ List getProductProfile() { return productService.list(); } + @GetMapping("/{ID}") + @ResponseBody + Product getProduct(@PathVariable long ID) { + return productService.getID(ID); + } + } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index dd7b7d4..8093605 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -38,7 +38,9 @@ public List list() { return repository.findAll(); } - + public Product getID(Long id){ + return repository.findById(id).orElse(null); + }; public int count() { return (int) repository.count(); From 6b6fb9abdeb9ad9d03754b19224ce5e735a3a88e Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 18 Nov 2023 00:00:23 +0800 Subject: [PATCH 027/163] feat: able to upload a product with no fully validation --- .../spring/controller/ProductController.java | 23 +++++++++++++++++++ .../security/SecurityConfiguration.java | 1 + 2 files changed, 24 insertions(+) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index cf3ebe8..42833ae 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -5,8 +5,11 @@ import ntou.auction.spring.data.entity.ProductRequest; import ntou.auction.spring.data.service.ProductService; import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; +import java.util.Collections; import java.util.List; +import java.util.Map; @RestController @@ -53,5 +56,25 @@ Product getProduct(@PathVariable long ID) { return productService.getID(ID); } + @PostMapping("/add") + ResponseEntity> postProduct(@Valid @RequestBody ProductRequest request){ //productrequest的限制 + + Map successMessage = Collections.singletonMap("456","恭喜"); + + Product product = new Product(); + + product.setProductName(request.getProductName()); + product.setProductDescription("123"); + product.setPrice(10000L); + product.setSeller("wei"); + product.setIsFixedPrice(true); + product.setUpsetPrice(1000L); + product.setProductImage("123"); + product.setProductType(request.getProductType()); + product.setCurrentPrice(123L); + + productService.store(product); + return ResponseEntity.ok(successMessage); + } } diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 088f98c..1c7548d 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -78,6 +78,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.POST, "/api/v1/account/users").permitAll() .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) .requestMatchers( HttpMethod.GET,"/api/v1/product/**").permitAll() + .requestMatchers( HttpMethod.POST,"/api/v1/product/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session From e47e5f330ffc8fcec19366b3cc2f7367d391598c Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 18 Nov 2023 21:05:02 +0800 Subject: [PATCH 028/163] feat: able to upload a product with no fully validation --- .../spring/controller/ProductController.java | 1 + .../RestResponseEntityExceptionHandler.java | 43 +++++++++++++++++++ .../spring/data/entity/ProductRequest.java | 26 ++++++++--- 3 files changed, 64 insertions(+), 6 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 42833ae..b6ee27d 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -60,6 +60,7 @@ Product getProduct(@PathVariable long ID) { ResponseEntity> postProduct(@Valid @RequestBody ProductRequest request){ //productrequest的限制 Map successMessage = Collections.singletonMap("456","恭喜"); + Map productNameTooLong = Collections.singletonMap("message","87"); Product product = new Product(); diff --git a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java new file mode 100644 index 0000000..aaea094 --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java @@ -0,0 +1,43 @@ +package ntou.auction.spring.controller; + +import jakarta.validation.ConstraintViolation; +import jakarta.validation.ConstraintViolationException; +import org.apache.tomcat.util.buf.StringUtils; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatusCode; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.FieldError; +import org.springframework.validation.ObjectError; +import org.springframework.web.bind.MethodArgumentNotValidException; +import org.springframework.web.bind.annotation.ControllerAdvice; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.context.request.WebRequest; +import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; + +import java.util.*; + +@ControllerAdvice +public class RestResponseEntityExceptionHandler extends ResponseEntityExceptionHandler { + + @ExceptionHandler(ConstraintViolationException.class) + public ResponseEntity> handleConstraintViolationException(ConstraintViolationException ex) { + ConstraintViolation constraintViolation = ex.getConstraintViolations().iterator().next(); + String errorMessage = constraintViolation.getMessage(); + Map response = Collections.singletonMap("message", errorMessage); + return ResponseEntity.badRequest().body(response); + } + + @Override + protected ResponseEntity handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) { + List errors = new ArrayList<>(); + for (FieldError error : ex.getBindingResult().getFieldErrors()) { + errors.add(error.getDefaultMessage()); + } + for (ObjectError error : ex.getBindingResult().getGlobalErrors()) { + errors.add(error.getDefaultMessage()); + } + Map response = Collections.singletonMap("message", StringUtils.join(errors,'\n')); + return handleExceptionInternal( + ex, response, headers, status, request); + } +} \ No newline at end of file diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java index 711d505..562cc71 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java +++ b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java @@ -1,5 +1,7 @@ package ntou.auction.spring.data.entity; +import jakarta.persistence.Column; +import jakarta.persistence.Lob; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; @@ -11,17 +13,29 @@ @AllArgsConstructor public class ProductRequest{ - - @Length(min = 1, max = 32) + @NotNull + @Length(min = 1, max = 32 , message = "商品名稱至多32個中文字") //32個中文字 private String productName; - - +/* + @NotNull + private Long price; +*/ @Length(min = 1, max = 32) private String productType; +/* + @NotNull + private Boolean isFixedPrice; + @Length(min = 1, max = 256) + private String productDescription; - private String searchType; - + private Long upsetPrice; //lowest requested price + private Long currentPrice; + @Lob + @Column(length = 5242880) + private String productImage; +*/ + private String searchType; } From 94b0995f8f308acd1771bbf619ff147181b946f2 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 19 Nov 2023 13:21:18 +0800 Subject: [PATCH 029/163] fix : adjust default testcase to 1 to avoid id increment --- src/main/resources/data.sql | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index eb57154..4c3845e 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -9,11 +9,12 @@ insert into user_roles (user_id, roles) values (1, 'ADMIN'); insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) -values (1,1,'IPhone13','electronic',10000,true,'ggggg','weichun',1000,1500,'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'); - +values (1,1,'IPhone13','electronic',10000,true,'ggggg','weichun',1000,1500,null); +/* insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) -values (2,2,'衛生紙','Daily need', 10000,true,'ggggg','weichun',1000,1500,'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'); +values (2,2,'衛生紙','Daily need', 10000,true,'ggggg','weichun',1000,1500,null); insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) -values (3,3,'action figure','Stationary',10000,true,'ggggg','weichun',1000,1500,'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'); +values (3,3,'action figure','Stationary',10000,true,'ggggg','weichun',1000,1500,null); +*/ \ No newline at end of file From 8ebccc8844104fbc5f9b4a74a390f808dce42b6d Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 19 Nov 2023 13:22:59 +0800 Subject: [PATCH 030/163] fix : add @length to productImage to validation and remove some notNull --- .../java/ntou/auction/spring/data/entity/Product.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index 7c1039f..a595cce 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -15,10 +15,10 @@ public class Product extends AbstractEntity { @NotNull - @Length(min = 1, max = 32) + @Length(min = 1, max = 128) private String productName; - @NotNull + @Length(min = 1, max = 32) private String productType; @@ -28,7 +28,7 @@ public class Product extends AbstractEntity { @NotNull private Boolean isFixedPrice; - @NotNull + @Length(min = 1, max = 256) private String productDescription; @@ -49,6 +49,7 @@ public class Product extends AbstractEntity { // if avatar is more than 5MB, need to modify column length @Lob @Column(length = 5242880) - private byte[] productImage; + @Length(min = 1, max = 5242880) + private String productImage; } From a7e8ca3c78848f879ddf5a481cad5098fb96be10 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 19 Nov 2023 13:25:24 +0800 Subject: [PATCH 031/163] feat : add more error message to specific data which post from FrontEnd --- .../spring/data/entity/ProductRequest.java | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java index 562cc71..27d9541 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java +++ b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java @@ -2,6 +2,7 @@ import jakarta.persistence.Column; import jakarta.persistence.Lob; +import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; @@ -13,29 +14,28 @@ @AllArgsConstructor public class ProductRequest{ - @NotNull - @Length(min = 1, max = 32 , message = "商品名稱至多32個中文字") //32個中文字 + @NotNull (message="商品名稱不得為空") + @Length(min = 1, max = 128 , message = "商品名稱至多32個中文字") private String productName; -/* - @NotNull + + @NotNull (message="價格不得為空") + @Min (value = 0,message = "價格不得為零") private Long price; -*/ + + @NotNull (message = "請填寫販售方式") + private Boolean isFixedPrice; + @Length(min = 1, max = 32) private String productType; -/* - @NotNull - private Boolean isFixedPrice; - @Length(min = 1, max = 256) + @Length(min = 1, max = 256,message = "商品敘述過長") private String productDescription; - private Long upsetPrice; //lowest requested price - - private Long currentPrice; - @Lob @Column(length = 5242880) + @Length(min = 1, max = 5242880 ,message = "圖片檔案過大，請重新上傳") private String productImage; -*/ + + private String searchType; } From 794ecc98580611729c73d618d880ad60c8582007 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 19 Nov 2023 13:25:57 +0800 Subject: [PATCH 032/163] fix : enhance api --- .../auction/spring/controller/ProductController.java | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index b6ee27d..dcd2d3b 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -40,6 +40,7 @@ else if(type == 2){ //find by classification String pt = request.getProductType(); return productService.findByProductClassification(pt); } + return productService.list(); } @@ -56,19 +57,19 @@ Product getProduct(@PathVariable long ID) { return productService.getID(ID); } - @PostMapping("/add") + @PostMapping("/product") ResponseEntity> postProduct(@Valid @RequestBody ProductRequest request){ //productrequest的限制 - Map successMessage = Collections.singletonMap("456","恭喜"); - Map productNameTooLong = Collections.singletonMap("message","87"); + Map successMessage = Collections.singletonMap("message","成功上架"); + Product product = new Product(); product.setProductName(request.getProductName()); product.setProductDescription("123"); - product.setPrice(10000L); + product.setPrice(request.getPrice()); product.setSeller("wei"); - product.setIsFixedPrice(true); + product.setIsFixedPrice(request.getIsFixedPrice()); product.setUpsetPrice(1000L); product.setProductImage("123"); product.setProductType(request.getProductType()); From e6c66e6578dd02d1bb6ab29e1beaa631573ee4e6 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 20 Nov 2023 23:52:22 +0800 Subject: [PATCH 033/163] fix : seller change to sellerID --- .../ntou/auction/spring/data/entity/Product.java | 5 ++--- src/main/resources/data.sql | 12 ++++++------ 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index a595cce..e8df001 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -33,12 +33,11 @@ public class Product extends AbstractEntity { private String productDescription; @NotNull - @Length(min = 1, max = 32) - private String seller; + private Long sellerID; //followings are non-isFixedPrice feature - @NotNull + private Long upsetPrice; //lowest requested price diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 4c3845e..5a39dce 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -8,13 +8,13 @@ values (1, 'USER'); insert into user_roles (user_id, roles) values (1, 'ADMIN'); -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) -values (1,1,'IPhone13','electronic',10000,true,'ggggg','weichun',1000,1500,null); +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,sellerID,upset_price,current_price,product_image) +values (1,1,'IPhone13','electronic',10000,true,'ggggg',1057088,1000,1500,null); /* -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) -values (2,2,'衛生紙','Daily need', 10000,true,'ggggg','weichun',1000,1500,null); +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,sellerID,upset_price,current_price,product_image) +values (2,3,'衛生紙','Daily need', 10000,true,'ggggg',987987,1000,1500,null); -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,seller,upset_price,current_price,product_image) -values (3,3,'action figure','Stationary',10000,true,'ggggg','weichun',1000,1500,null); +insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,sellerID,upset_price,current_price,product_image) +values (3,4,'action figure','Stationary',10000,true,'ggggg',456456,1000,1500,null); */ \ No newline at end of file From 34d2cebc18716dd4cc6fb556c2a13976e3f4c3bd Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 20 Nov 2023 23:54:50 +0800 Subject: [PATCH 034/163] fix : findAllByProductType --- .../ntou/auction/spring/data/service/ProductRepository.java | 4 ++-- .../java/ntou/auction/spring/data/service/ProductService.java | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index ea5e5c5..0338cc9 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -23,8 +23,8 @@ public interface ProductRepository extends JpaRepository, // ?1:productName - @Query("select p from Product p where p.productType = ?1 ") - List findByProductType(@Param("productType") String productType); + + List findAllByProductType(String productType); } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index 8093605..5471803 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -61,7 +61,7 @@ public List findByProductName(String productName) { } public List findByProductClassification(String productType){ - return repository.findByProductType(productType); + return repository.findAllByProductType(productType); } } From f448110ae17d8d14efe095a90ecb5fb19f4f5a98 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 20 Nov 2023 23:56:39 +0800 Subject: [PATCH 035/163] feat : The simulate data from FrontEnd to search product --- .../spring/data/entity/ProductRequestGet.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/ProductRequestGet.java diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductRequestGet.java b/src/main/java/ntou/auction/spring/data/entity/ProductRequestGet.java new file mode 100644 index 0000000..501a6c8 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ProductRequestGet.java @@ -0,0 +1,27 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.Lob; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ProductRequestGet { + + + + @Length(min = 1, max = 128) + private String productName; + + @Length(min = 1, max = 32) + private String productType; + + @NotNull(message = "請填寫搜尋方式") + private String searchType; +} From 7a70ca035d15cff90a09f0bbe66e07c783495d9f Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 20 Nov 2023 23:57:13 +0800 Subject: [PATCH 036/163] fix : The simulate data from FrontEnd to insert product --- .../ntou/auction/spring/data/entity/ProductRequest.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java index 27d9541..347794b 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java +++ b/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java @@ -31,11 +31,13 @@ public class ProductRequest{ @Length(min = 1, max = 256,message = "商品敘述過長") private String productDescription; + private Long upsetPrice; //lowest requested price + + private Long currentPrice; + @Lob @Column(length = 5242880) @Length(min = 1, max = 5242880 ,message = "圖片檔案過大，請重新上傳") private String productImage; - - private String searchType; } From 4aca23d49f9e9c407e6376e79de963bf014ffb2a Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 20 Nov 2023 23:59:09 +0800 Subject: [PATCH 037/163] fix : set sellerID from valid user. fix : add condition to the isFixedFrice --- .../spring/controller/ProductController.java | 31 ++++++++++++++----- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index dcd2d3b..8da4836 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -3,7 +3,10 @@ import jakarta.validation.Valid; import ntou.auction.spring.data.entity.Product; import ntou.auction.spring.data.entity.ProductRequest; +import ntou.auction.spring.data.entity.ProductRequestGet; import ntou.auction.spring.data.service.ProductService; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; @@ -17,17 +20,20 @@ @CrossOrigin(origins = "http://localhost:3000") public class ProductController { private final ProductService productService; + private final UserIdentity userIdentity; + private final UserService userService; - - public ProductController(ProductService productService) { + public ProductController(ProductService productService,UserIdentity userIdentity,UserService userService) { this.productService = productService; + this.userIdentity = userIdentity; + this.userService = userService; } @GetMapping("/product") @ResponseBody - public ListgetProductName(@Valid @RequestBody ProductRequest request) { + public ListgetProductName(@Valid @RequestBody ProductRequestGet request) { long type =Integer.parseInt(request.getSearchType()); @@ -66,14 +72,23 @@ ResponseEntity> postProduct(@Valid @RequestBody ProductReques Product product = new Product(); product.setProductName(request.getProductName()); - product.setProductDescription("123"); + product.setProductDescription(request.getProductDescription()); product.setPrice(request.getPrice()); - product.setSeller("wei"); product.setIsFixedPrice(request.getIsFixedPrice()); - product.setUpsetPrice(1000L); - product.setProductImage("123"); + product.setProductImage(request.getProductImage()); product.setProductType(request.getProductType()); - product.setCurrentPrice(123L); + + product.setSellerID(20231120L); + if(request.getIsFixedPrice()){ + product.setCurrentPrice(null); + product.setUpsetPrice(null); + } + else if(!request.getIsFixedPrice()){ + product.setCurrentPrice(request.getCurrentPrice()); + product.setUpsetPrice(request.getUpsetPrice()); + } + product.setSellerID(userService.findByUsername(userIdentity.getUsername()).getId()); + productService.store(product); return ResponseEntity.ok(successMessage); From ddf8fb6954c748a9f0d957a438bec4a8c4bad82b Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 22 Nov 2023 22:59:08 +0800 Subject: [PATCH 038/163] fix : add product testcase --- src/main/resources/data.sql | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 5a39dce..0235b53 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -8,13 +8,16 @@ values (1, 'USER'); insert into user_roles (user_id, roles) values (1, 'ADMIN'); -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,sellerID,upset_price,current_price,product_image) -values (1,1,'IPhone13','electronic',10000,true,'ggggg',1057088,1000,1500,null); - +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) +values (1,1,'IPhone13','electronic',true,'ggggg',1057088,null,3,1500,"2023-11-04 19:45:00",null,null,null); /* -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,sellerID,upset_price,current_price,product_image) -values (2,3,'衛生紙','Daily need', 10000,true,'ggggg',987987,1000,1500,null); +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) +values (1,2,'IPhone18','electronic',true,'ggggg',1057088,null,3,1500,"2023-11-04 19:45:00",null,null,null); + + +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) +values (1,3,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); -insert into product (version,id,product_name,product_type, price,is_fixed_price,product_description,sellerID,upset_price,current_price,product_image) -values (3,4,'action figure','Stationary',10000,true,'ggggg',456456,1000,1500,null); +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) +values (1,4,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); */ \ No newline at end of file From 427eec6f7f9b5b32bb109a7f4268adbde72d1f86 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 22 Nov 2023 23:02:08 +0800 Subject: [PATCH 039/163] fix : fix product api for posting fixed or non-fixed product --- ...java => PostFixedPriceProductRequest.java} | 18 ++++--- .../PostNonFixedPriceProductRequest.java | 48 +++++++++++++++++++ 2 files changed, 56 insertions(+), 10 deletions(-) rename src/main/java/ntou/auction/spring/data/entity/{ProductRequest.java => PostFixedPriceProductRequest.java} (74%) create mode 100644 src/main/java/ntou/auction/spring/data/entity/PostNonFixedPriceProductRequest.java diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/PostFixedPriceProductRequest.java similarity index 74% rename from src/main/java/ntou/auction/spring/data/entity/ProductRequest.java rename to src/main/java/ntou/auction/spring/data/entity/PostFixedPriceProductRequest.java index 347794b..214fc50 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductRequest.java +++ b/src/main/java/ntou/auction/spring/data/entity/PostFixedPriceProductRequest.java @@ -12,32 +12,30 @@ @Data @NoArgsConstructor @AllArgsConstructor -public class ProductRequest{ +public class PostFixedPriceProductRequest { @NotNull (message="商品名稱不得為空") @Length(min = 1, max = 128 , message = "商品名稱至多32個中文字") private String productName; @NotNull (message="價格不得為空") - @Min (value = 0,message = "價格不得為零") - private Long price; + @Min (value = 1,message = "價格須為正整數") + private Long currentPrice; - @NotNull (message = "請填寫販售方式") - private Boolean isFixedPrice; @Length(min = 1, max = 32) private String productType; - @Length(min = 1, max = 256,message = "商品敘述過長") + @Length(min = 1, max = 20971520,message = "商品敘述過長") private String productDescription; - private Long upsetPrice; //lowest requested price - - private Long currentPrice; - @Lob @Column(length = 5242880) @Length(min = 1, max = 5242880 ,message = "圖片檔案過大，請重新上傳") private String productImage; + @NotNull (message="商品數量不得為空") + @Min (value = 1,message = "商品至少一個") + private Long productAmount; + } diff --git a/src/main/java/ntou/auction/spring/data/entity/PostNonFixedPriceProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/PostNonFixedPriceProductRequest.java new file mode 100644 index 0000000..390da51 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/PostNonFixedPriceProductRequest.java @@ -0,0 +1,48 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.Lob; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class PostNonFixedPriceProductRequest { + + @NotNull (message="商品名稱不得為空") + @Length(min = 1, max = 128 , message = "商品名稱至多32個中文字") + private String productName; + + @NotNull + @Min (value = 1,message = "價格須為正整數") + private Long upsetPrice; //lowest requested price + + @NotNull + @Min (value = 1,message = "每口叫價須為正整數") + private Long bidIncrement; + + @NotNull (message="商品數量不得為空") + private Long productAmount; + + @NotNull + private String finishTime; + + @Length(min = 1, max = 32) + private String productType; + + @Length(min = 1, max = 20971520,message = "商品敘述過長") + private String productDescription; + + @Lob + @Column(length = 5242880) + @Length(min = 1, max = 5242880 ,message = "圖片檔案過大，請重新上傳") + private String productImage; + + + +} From 50c23df460746e35ee286894fae47ca632b8eca4 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 22 Nov 2023 23:02:50 +0800 Subject: [PATCH 040/163] fix : add product attribute(amount+time) --- .../auction/spring/data/entity/Product.java | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index e8df001..f0496b8 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -1,12 +1,16 @@ package ntou.auction.spring.data.entity; +import com.fasterxml.jackson.annotation.JsonFormat; import jakarta.persistence.*; +import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import org.hibernate.validator.constraints.Length; +import java.time.LocalDateTime; + @Entity @Data @NoArgsConstructor @@ -22,28 +26,35 @@ public class Product extends AbstractEntity { @Length(min = 1, max = 32) private String productType; - @NotNull - private Long price; @NotNull private Boolean isFixedPrice; - @Length(min = 1, max = 256) + @Length(min = 1, max = 20971520) private String productDescription; @NotNull private Long sellerID; + private Long productAmount; + //followings are non-isFixedPrice feature private Long upsetPrice; //lowest requested price - + @NotNull private Long currentPrice; + private Long bidIncrement; + + @NotNull + @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") + private LocalDateTime updateTime; + @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") + private LocalDateTime finishTime; // if avatar is more than 5MB, need to modify column length @Lob From cc530da0fbf2ade0a0a2ef10aa75dea17caa7ca5 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 22 Nov 2023 23:04:03 +0800 Subject: [PATCH 041/163] fix : fix product api for posting product --- .../spring/controller/ProductController.java | 63 ++++++++++++++----- 1 file changed, 49 insertions(+), 14 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 8da4836..816cda7 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -1,8 +1,9 @@ package ntou.auction.spring.controller; import jakarta.validation.Valid; +import ntou.auction.spring.data.entity.PostNonFixedPriceProductRequest; import ntou.auction.spring.data.entity.Product; -import ntou.auction.spring.data.entity.ProductRequest; +import ntou.auction.spring.data.entity.PostFixedPriceProductRequest; import ntou.auction.spring.data.entity.ProductRequestGet; import ntou.auction.spring.data.service.ProductService; import ntou.auction.spring.data.service.UserIdentity; @@ -10,6 +11,9 @@ import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; import java.util.Collections; import java.util.List; import java.util.Map; @@ -63,8 +67,8 @@ Product getProduct(@PathVariable long ID) { return productService.getID(ID); } - @PostMapping("/product") - ResponseEntity> postProduct(@Valid @RequestBody ProductRequest request){ //productrequest的限制 + @PostMapping("/fixedproduct") + ResponseEntity> postProduct(@Valid @RequestBody PostFixedPriceProductRequest request){ //productrequest的限制 Map successMessage = Collections.singletonMap("message","成功上架"); @@ -73,25 +77,56 @@ ResponseEntity> postProduct(@Valid @RequestBody ProductReques product.setProductName(request.getProductName()); product.setProductDescription(request.getProductDescription()); - product.setPrice(request.getPrice()); - product.setIsFixedPrice(request.getIsFixedPrice()); + product.setIsFixedPrice(true); product.setProductImage(request.getProductImage()); product.setProductType(request.getProductType()); + product.setCurrentPrice(request.getCurrentPrice()); + product.setUpsetPrice(null); + product.setBidIncrement(null); + product.setProductAmount(request.getProductAmount()); + product.setSellerID(userService.findByUsername(userIdentity.getUsername()).getId()); + + product.setUpdateTime(LocalDateTime.now()); + + + productService.store(product); + return ResponseEntity.ok(successMessage); + } + + @PostMapping("/nonfixedproduct") + ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedPriceProductRequest request){ //productrequest的限制 + + Map successMessage = Collections.singletonMap("message","成功上架"); + Map fail = Collections.singletonMap("message","截止時間錯誤"); + + Product product = new Product(); + + product.setProductName(request.getProductName()); + product.setProductDescription(request.getProductDescription()); + product.setIsFixedPrice(false); + product.setProductImage(request.getProductImage()); + product.setProductType(request.getProductType()); + product.setCurrentPrice(request.getUpsetPrice()); + product.setUpsetPrice(request.getUpsetPrice()); + product.setBidIncrement(request.getBidIncrement()); + product.setProductAmount(1L); + + LocalDateTime now = LocalDateTime.now(); - product.setSellerID(20231120L); - if(request.getIsFixedPrice()){ - product.setCurrentPrice(null); - product.setUpsetPrice(null); - } - else if(!request.getIsFixedPrice()){ - product.setCurrentPrice(request.getCurrentPrice()); - product.setUpsetPrice(request.getUpsetPrice()); - } product.setSellerID(userService.findByUsername(userIdentity.getUsername()).getId()); + product.setUpdateTime(now); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + LocalDateTime dateTime = LocalDateTime.parse(request.getFinishTime(), formatter); + + if(!now.isBefore(dateTime)){ + return ResponseEntity.badRequest().body(fail); + } + product.setFinishTime(dateTime); productService.store(product); return ResponseEntity.ok(successMessage); } + } From 711ea56d0549f0450ce76f77ff599f09f1bd84aa Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 22 Nov 2023 23:04:43 +0800 Subject: [PATCH 042/163] fix : fix post product privilege --- .../java/ntou/auction/spring/security/SecurityConfiguration.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index d3266f5..1bc613d 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -79,7 +79,6 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.POST, "/api/v1/account/users").permitAll() .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) .requestMatchers( HttpMethod.GET,"/api/v1/product/**").permitAll() - .requestMatchers( HttpMethod.POST,"/api/v1/product/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session From 09204fd3bdf694181c1d8940748baee5faf0baaf Mon Sep 17 00:00:00 2001 From: Ray Date: Thu, 23 Nov 2023 21:48:13 +0800 Subject: [PATCH 043/163] feat: add Shoppingcart entity --- .../spring/data/entity/Shoppingcart.java | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java new file mode 100644 index 0000000..1629ba5 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -0,0 +1,35 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.*; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import java.util.ArrayList; +import java.util.List; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +@Table(name = "shoppingcart") +public class Shoppingcart extends AbstractEntity { + + @NotNull + private Long userid; + + @ElementCollection + @CollectionTable(name = "productId") + private List productId = new ArrayList<>(); + + public @NotNull Long getUserId() { + return userid; + } + public void addProductId(Long product) { + productId.add(product); + } + + public boolean deleteProduct(Long product) { + return productId.remove(product); + } +} From c6e03e07a32d6805d6931b56ee698c8c528e3679 Mon Sep 17 00:00:00 2001 From: Ray Date: Thu, 23 Nov 2023 21:50:26 +0800 Subject: [PATCH 044/163] feat: introduce Shoppingcart service --- .../data/service/ShoppingcartRepository.java | 24 ++++++++ .../data/service/ShoppingcartService.java | 61 +++++++++++++++++++ 2 files changed, 85 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java create mode 100644 src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java new file mode 100644 index 0000000..6620533 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java @@ -0,0 +1,24 @@ +package ntou.auction.spring.data.service; + +import jakarta.transaction.Transactional; +import ntou.auction.spring.data.entity.Shoppingcart; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Modifying; +import org.springframework.data.jpa.repository.Query; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public interface ShoppingcartRepository extends JpaRepository, JpaSpecificationExecutor { + @Modifying + @Query(value = "insert into shoppingcart(userId, productId) values (?1, ?2)", nativeQuery = true) + public void addShoppingCart(Long userId, List productId); + + Shoppingcart findById(long id); + //@Query(value = "select s from Shoppingcart s where s.id = ?1") + Optional findByUserid(Long id); + @Transactional + public List deleteByUserid(Long UserId); +} diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java new file mode 100644 index 0000000..b532596 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -0,0 +1,61 @@ +package ntou.auction.spring.data.service; + +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.Shoppingcart; +import org.springframework.stereotype.Service; + +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.List; + +@Service +public class ShoppingcartService { + private final ShoppingcartRepository repository; + + public ShoppingcartService(ShoppingcartRepository repository) { + this.repository = repository; + } + + public Shoppingcart getByUserId(Long userId) { + return repository.findByUserid(userId).orElse(null); + } + + public List list() { + return repository.findAll(); + } + + public void addUser(Long userId) { + List product = new ArrayList<>(); + repository.addShoppingCart(userId, product); + } + + public int count() { + return (int) repository.count(); + } + + public boolean deleteShoppingcartByUserId(Long userId) { + if(repository.findByUserid(userId).isEmpty()) return false; + repository.deleteByUserid(userId); + return true; + } + + public void addProductByUserId(Long userId, Long productId) { + Shoppingcart userShoppingcart = getByUserId(userId); + if(userShoppingcart==null) { + List product = new ArrayList<>(); + Shoppingcart newShoppingcart = new Shoppingcart(userId, product); + repository.save(newShoppingcart); + userShoppingcart = getByUserId(userId); + } + userShoppingcart.addProductId(productId); + repository.save(userShoppingcart); + } + + public boolean deleteProductByUserId(Long userId, Long productId) { + Shoppingcart userShoppingcart = getByUserId(userId); + boolean result = userShoppingcart.deleteProduct(productId); + if(!result) return false; + repository.save(userShoppingcart); + return true; + } +} From 9d4ad52225bc11c258ea2f2afcb3c7120defb855 Mon Sep 17 00:00:00 2001 From: Ray Date: Thu, 23 Nov 2023 21:54:57 +0800 Subject: [PATCH 045/163] feat: Introduce a REST Controller for Shoppingcart with error handling. --- .../controller/ShoppingcartController.java | 83 +++++++++++++++++++ .../data/entity/ShoppingcartRequest.java | 14 ++++ 2 files changed, 97 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/controller/ShoppingcartController.java create mode 100644 src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java new file mode 100644 index 0000000..7c08646 --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -0,0 +1,83 @@ +package ntou.auction.spring.controller; + +import jakarta.validation.Valid; +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.Shoppingcart; +import ntou.auction.spring.data.entity.ShoppingcartRequest; +import ntou.auction.spring.data.service.ProductService; +import ntou.auction.spring.data.service.ShoppingcartService; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +@RestController +@RequestMapping(value = "/api/v1/shoppingcart", produces = MediaType.APPLICATION_JSON_VALUE) +@CrossOrigin(origins = "http://localhost:3000") +public class ShoppingcartController { + private final ShoppingcartService shoppingcartService; + private final ProductService productService; + private static final Map successMessage = Collections.singletonMap("message","成功"); + private static final Map failMessage = Collections.singletonMap("message","好像發生了什麼錯誤，請檢查一下腦袋"); + + private final UserService userService; + + private final UserIdentity userIdentity; + + public ShoppingcartController(ShoppingcartService shoppingcartService, ProductService productService, UserService userService, UserIdentity userIdentity) { + this.shoppingcartService = shoppingcartService; + this.productService = productService; + this.userService = userService; + this.userIdentity = userIdentity; + } + @GetMapping("/shoppingcart") + @ResponseBody + List getShoppingcartProfile() { return shoppingcartService.list(); } + @GetMapping("/{userId}") + @ResponseBody + Shoppingcart getUserShoppingcart(@PathVariable long userId) { + return shoppingcartService.getByUserId(userId); + } + + @GetMapping("/view") + @ResponseBody + List getProduct() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Shoppingcart userShoppingcart = getUserShoppingcart(userId); + if(userShoppingcart==null) return null; + List result = new ArrayList<>(); + for(Long productId: userShoppingcart.getProductId()) { + result.add(productService.getID(productId)); + } + return result; + } + @PostMapping("/add") + ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long addProductId = request.getProductId(); + shoppingcartService.addProductByUserId(userId, addProductId); + return ResponseEntity.ok(successMessage); + } + + @DeleteMapping("/delete") + ResponseEntity> deleteProduct(@Valid @RequestBody ShoppingcartRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long addProductId = request.getProductId(); + boolean result = shoppingcartService.deleteProductByUserId(userId, addProductId); + return (result?ResponseEntity.ok(successMessage):ResponseEntity.ok(failMessage)); + } + + @DeleteMapping("/deleteall") + ResponseEntity> deleteAllProduct() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + boolean result = shoppingcartService.deleteShoppingcartByUserId(userId); + if(!result) return ResponseEntity.ok(failMessage); + return ResponseEntity.ok(successMessage); + } +} diff --git a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java new file mode 100644 index 0000000..3133711 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java @@ -0,0 +1,14 @@ +package ntou.auction.spring.data.entity; + +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ShoppingcartRequest { + @NotNull + private Long productId; +} From 63a9030b0262cbc222e43c4ea25b66f5d44c73f0 Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 24 Nov 2023 00:01:53 +0800 Subject: [PATCH 046/163] feat: add parameter of amount to Shoppingcart --- .../spring/data/entity/Shoppingcart.java | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java index 1629ba5..de7f03b 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -5,8 +5,8 @@ import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import java.util.ArrayList; -import java.util.List; +import java.util.HashMap; +import java.util.Map; @Entity @Data @@ -20,16 +20,25 @@ public class Shoppingcart extends AbstractEntity { @ElementCollection @CollectionTable(name = "productId") - private List productId = new ArrayList<>(); + private Map productItems = new HashMap<>(); public @NotNull Long getUserId() { return userid; } - public void addProductId(Long product) { - productId.add(product); + + public void addProductId(Long product, Long amount) { + if(!productItems.containsKey(product)) productItems.put(product, 0L); + productItems.replace(product, productItems.get(product)+amount); } - public boolean deleteProduct(Long product) { - return productId.remove(product); + public boolean deleteProduct(Long product, Long amount) { + if (productItems.get(product) == null) return false; + if (productItems.get(product) == 0L) { + productItems.remove(product); + return false; + } + productItems.replace(product, productItems.get(product) - amount); + if (productItems.get(product) == 0L) productItems.remove(product); + return true; } } From a1a5718a8c8653da6277c8e173e8fcdfd2ee8fc1 Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 24 Nov 2023 00:08:50 +0800 Subject: [PATCH 047/163] feat: repair the Shoppingcart system to match it by the amount parameter --- .../spring/controller/ProductController.java | 2 +- .../controller/ShoppingcartController.java | 10 +++++----- .../spring/data/service/ShoppingcartService.java | 16 ++++++++++------ 3 files changed, 16 insertions(+), 12 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index b6ee27d..e6362df 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -70,7 +70,7 @@ ResponseEntity> postProduct(@Valid @RequestBody ProductReques product.setSeller("wei"); product.setIsFixedPrice(true); product.setUpsetPrice(1000L); - product.setProductImage("123"); + product.setProductImage("123".getBytes()); product.setProductType(request.getProductType()); product.setCurrentPrice(123L); diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 7c08646..d69c5f8 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -1,7 +1,7 @@ package ntou.auction.spring.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.ProductAddAmount; import ntou.auction.spring.data.entity.Shoppingcart; import ntou.auction.spring.data.entity.ShoppingcartRequest; import ntou.auction.spring.data.service.ProductService; @@ -47,13 +47,13 @@ Shoppingcart getUserShoppingcart(@PathVariable long userId) { @GetMapping("/view") @ResponseBody - List getProduct() { + List getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Shoppingcart userShoppingcart = getUserShoppingcart(userId); if(userShoppingcart==null) return null; - List result = new ArrayList<>(); - for(Long productId: userShoppingcart.getProductId()) { - result.add(productService.getID(productId)); + List result = new ArrayList<>(); + for(Map.Entry product: userShoppingcart.getProductItems().entrySet()) { + result.add(new ProductAddAmount(productService.getID(product.getKey()), product.getValue())); } return result; } diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java index b532596..77b60e4 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -6,7 +6,9 @@ import java.lang.reflect.Array; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; @Service public class ShoppingcartService { @@ -34,28 +36,30 @@ public int count() { } public boolean deleteShoppingcartByUserId(Long userId) { - if(repository.findByUserid(userId).isEmpty()) return false; + if (repository.findByUserid(userId).isEmpty()) return false; repository.deleteByUserid(userId); return true; } public void addProductByUserId(Long userId, Long productId) { Shoppingcart userShoppingcart = getByUserId(userId); - if(userShoppingcart==null) { - List product = new ArrayList<>(); + if (userShoppingcart == null) { + Map product = new HashMap<>(); Shoppingcart newShoppingcart = new Shoppingcart(userId, product); repository.save(newShoppingcart); userShoppingcart = getByUserId(userId); } - userShoppingcart.addProductId(productId); + userShoppingcart.addProductId(productId, 1L); repository.save(userShoppingcart); } public boolean deleteProductByUserId(Long userId, Long productId) { Shoppingcart userShoppingcart = getByUserId(userId); - boolean result = userShoppingcart.deleteProduct(productId); - if(!result) return false; + if (userShoppingcart == null) return false; + boolean result = userShoppingcart.deleteProduct(productId, 1L); + if (!result) return false; repository.save(userShoppingcart); + if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); return true; } } From 9f927deb379ab75bd0cd8384fd217880e70f09f3 Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 24 Nov 2023 00:09:40 +0800 Subject: [PATCH 048/163] feat: add ProductAddAmount class --- .../auction/spring/data/entity/ProductAddAmount.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java b/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java new file mode 100644 index 0000000..4366945 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java @@ -0,0 +1,12 @@ +package ntou.auction.spring.data.entity; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +@Getter +@NoArgsConstructor +@AllArgsConstructor +public class ProductAddAmount{ + private Product product; + private Long amount; +} From 7a4b3f731638f8d27a21939566ce4bd851c3eb34 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 24 Nov 2023 17:08:28 +0800 Subject: [PATCH 049/163] feat : bid product with reasonable check --- .../spring/controller/ProductController.java | 12 ++++++++++++ .../spring/data/service/ProductService.java | 17 +++++++++++++---- 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 816cda7..ca7405a 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -128,5 +128,17 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedP return ResponseEntity.ok(successMessage); } + @PatchMapping("/{ID}/{bid}") //商品ID 出價。出價也需傳入token + ResponseEntity> bidProduct(@PathVariable Long ID,@PathVariable Long bid){ + + Map successMessage = Collections.singletonMap("message","成功出價"); + Map failMessage = Collections.singletonMap("message","出價不合理，重新出價"); + + if(!productService.isBidReasonable(bid,ID)){ + return ResponseEntity.badRequest().body(failMessage); + } + productService.bid(bid,ID); + return ResponseEntity.ok(successMessage); + } } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index 5471803..f35fe23 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -50,11 +50,20 @@ public void store(Product product) { repository.save(product); } -/* - public boolean isProductNameNonExist(String productName) { - return repository.findByProductName(productName) == null; + + public boolean isBidReasonable(Long bid, Long id) { + Product pr = this.getID(id); + return (bid - pr.getCurrentPrice()) >= pr.getBidIncrement(); } -*/ + public void bid(Long bid,Long id){ + if (this.isBidReasonable(bid,id)){ + System.out.println("合理"); + Product product = this.getID(id); + product.setCurrentPrice(bid); + this.store(product); + } + } + public List findByProductName(String productName) { return repository.findAllByFuzzyProductName(productName); From 0d5bb042026e97182e4aa0c96e4ebbe78b94af7b Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 24 Nov 2023 17:10:03 +0800 Subject: [PATCH 050/163] fix : fix unnecessary semicolon --- .../java/ntou/auction/spring/data/service/ProductService.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index f35fe23..d19349e 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -40,7 +40,7 @@ public List list() { public Product getID(Long id){ return repository.findById(id).orElse(null); - }; + } public int count() { return (int) repository.count(); From 2288b7720b47a187f695190614fcf01f6a888028 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 24 Nov 2023 23:24:10 +0800 Subject: [PATCH 051/163] fix: Retrieve data from the HTTP body instead of the URL parameters. --- .../spring/controller/ProductController.java | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index ca7405a..9884058 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -1,10 +1,7 @@ package ntou.auction.spring.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.PostNonFixedPriceProductRequest; -import ntou.auction.spring.data.entity.Product; -import ntou.auction.spring.data.entity.PostFixedPriceProductRequest; -import ntou.auction.spring.data.entity.ProductRequestGet; +import ntou.auction.spring.data.entity.*; import ntou.auction.spring.data.service.ProductService; import ntou.auction.spring.data.service.UserIdentity; import ntou.auction.spring.data.service.UserService; @@ -128,16 +125,16 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedP return ResponseEntity.ok(successMessage); } - @PatchMapping("/{ID}/{bid}") //商品ID 出價。出價也需傳入token - ResponseEntity> bidProduct(@PathVariable Long ID,@PathVariable Long bid){ + @PatchMapping("/bid") //商品ID 出價。出價也需傳入token + ResponseEntity> bidProduct(@Valid @RequestBody BidRequest request){ Map successMessage = Collections.singletonMap("message","成功出價"); - Map failMessage = Collections.singletonMap("message","出價不合理，重新出價"); + Map failMessage = Collections.singletonMap("message","出價不合理，出價需比當前最高價高" + productService.getID(request.getProductID()).getBidIncrement()); - if(!productService.isBidReasonable(bid,ID)){ + if(!productService.isBidReasonable(request.getBid(), request.getProductID())) { return ResponseEntity.badRequest().body(failMessage); } - productService.bid(bid,ID); + productService.bid(request.getBid(), request.getProductID()); return ResponseEntity.ok(successMessage); } From 89d26674532af94db89082e5f9023f885586bf98 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 25 Nov 2023 00:56:22 +0800 Subject: [PATCH 052/163] =?UTF-8?q?fix:=20=E8=AA=BF=E6=95=B4=E5=87=BA?= =?UTF-8?q?=E5=83=B9=E9=99=90=E5=88=B6=20feat:=20=E7=B4=80=E9=8C=84?= =?UTF-8?q?=E7=AB=B6=E6=A8=99=E8=B3=87=E8=A8=8A=20(=E5=87=BA=E5=83=B9?= =?UTF-8?q?=E8=80=85ID=EF=BC=8C=E5=87=BA=E5=83=B9)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 4 +++- .../spring/data/entity/BidRequest.java | 24 +++++++++++++++++++ .../auction/spring/data/entity/Product.java | 4 ++++ .../spring/data/service/ProductService.java | 19 ++++++++++----- 4 files changed, 44 insertions(+), 7 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/data/entity/BidRequest.java diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 9884058..0122272 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -134,7 +134,9 @@ ResponseEntity> bidProduct(@Valid @RequestBody BidRequest req if(!productService.isBidReasonable(request.getBid(), request.getProductID())) { return ResponseEntity.badRequest().body(failMessage); } - productService.bid(request.getBid(), request.getProductID()); + System.out.println(userIdentity.getUsername()); + productService.bid(request.getBid(), request.getProductID(),userService.findByUsername(userIdentity.getUsername()).getId()); + return ResponseEntity.ok(successMessage); } diff --git a/src/main/java/ntou/auction/spring/data/entity/BidRequest.java b/src/main/java/ntou/auction/spring/data/entity/BidRequest.java new file mode 100644 index 0000000..97f9d1c --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/BidRequest.java @@ -0,0 +1,24 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.Lob; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class BidRequest { + + @NotNull (message="商品ID不得為空") + private Long productID; + + @NotNull (message="出價不得為空") + @Min (value = 1,message = "出價須為正整數") + private Long bid; + +} diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index f0496b8..fdaa0c8 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -10,6 +10,7 @@ import org.hibernate.validator.constraints.Length; import java.time.LocalDateTime; +import java.util.Map; @Entity @Data @@ -41,6 +42,9 @@ public class Product extends AbstractEntity { //followings are non-isFixedPrice feature + @ElementCollection + @CollectionTable(name = "bidInfo") + private Map bidInfo; private Long upsetPrice; //lowest requested price diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index d19349e..ad67c43 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -1,11 +1,10 @@ package ntou.auction.spring.data.service; +import jakarta.validation.constraints.Null; import ntou.auction.spring.data.entity.Product; -import org.springframework.data.domain.Page; -import org.springframework.data.domain.Pageable; -import org.springframework.data.jpa.domain.Specification; import org.springframework.stereotype.Service; import java.util.List; +import java.util.Map; @Service @@ -13,9 +12,12 @@ public class ProductService { private final ProductRepository repository; - - public ProductService(ProductRepository repository) { + private final UserIdentity userIdentity; + private final UserService userService; + public ProductService(ProductRepository repository, UserIdentity userIdentity, UserService userService) { this.repository = repository; + this.userIdentity = userIdentity; + this.userService = userService; } public Product get(String productName) { @@ -53,13 +55,18 @@ public void store(Product product) { public boolean isBidReasonable(Long bid, Long id) { Product pr = this.getID(id); + if(pr.getCurrentPrice().equals(pr.getUpsetPrice()) && bid >= pr.getUpsetPrice() && pr.getBidInfo().isEmpty()){ + return true; + } return (bid - pr.getCurrentPrice()) >= pr.getBidIncrement(); } - public void bid(Long bid,Long id){ + public void bid(Long bid,Long id,Long userID){ if (this.isBidReasonable(bid,id)){ System.out.println("合理"); Product product = this.getID(id); product.setCurrentPrice(bid); + Map bidInfo = product.getBidInfo(); + bidInfo.put(userID,bid); this.store(product); } } From a8501f9a89d7bb3caf238b0f59a6eede417affc2 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 26 Nov 2023 11:51:13 +0800 Subject: [PATCH 053/163] fix: add function isExpired into product.java --- src/main/java/ntou/auction/spring/data/entity/Product.java | 7 +++++++ .../auction/spring/data/service/ProductRepository.java | 2 ++ 2 files changed, 9 insertions(+) diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index fdaa0c8..b70f698 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -66,4 +66,11 @@ public class Product extends AbstractEntity { @Length(min = 1, max = 5242880) private String productImage; + public boolean isExpired() { + if(isFixedPrice){ + return false; + } + LocalDateTime now = LocalDateTime.now(); + return !now.isBefore(this.finishTime); + } } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index 0338cc9..15cc95f 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -15,6 +15,8 @@ public interface ProductRepository extends JpaRepository, Product findByProductName(String productName); + List findAllByIsFixedPriceFalse(); + Product findById(long id); @Query("select p from Product p " + From c1811a26e26c3a22fc5eb3d18239803571f5fd40 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 26 Nov 2023 11:52:21 +0800 Subject: [PATCH 054/163] fix: add expiredTimeCheck to stop customer from bidding --- .../ntou/auction/spring/controller/ProductController.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 0122272..d2eae35 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -130,6 +130,12 @@ ResponseEntity> bidProduct(@Valid @RequestBody BidRequest req Map successMessage = Collections.singletonMap("message","成功出價"); Map failMessage = Collections.singletonMap("message","出價不合理，出價需比當前最高價高" + productService.getID(request.getProductID()).getBidIncrement()); + Map expired = Collections.singletonMap("message","競標已結束"); + + LocalDateTime now = LocalDateTime.now(); + if(!now.isBefore(productService.getID(request.getProductID()).getFinishTime())){ + return ResponseEntity.badRequest().body(expired); + } if(!productService.isBidReasonable(request.getBid(), request.getProductID())) { return ResponseEntity.badRequest().body(failMessage); From 9cedf2b9dffb050ade9f37de2cec541515697ff2 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 26 Nov 2023 11:53:08 +0800 Subject: [PATCH 055/163] fix: test multiple user to bid --- src/main/resources/data.sql | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 0235b53..39aafd2 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -3,21 +3,32 @@ insert into user (version, id, username, name, hashed_password, avatar_image, av values (1, 1, 'admin', 'admin', '{argon2}$argon2id$v=19$m=16384,t=2,p=1$S9swkCEbXj5O8cwbZdyrtQ$4RkxTGl3xkEfm51P/gc3FORCysPStozAsm6smOnQR18', null, null, 'admin@example.com', true, true, true, true); + +insert into user (version, id, username, name, hashed_password, avatar_image, avatar_image_name, email, + enabled, is_account_non_expired, is_account_non_locked, is_credentials_non_expired) +values (1, 2, 'shit', 'admin', + '{argon2}$argon2id$v=19$m=16384,t=2,p=1$S9swkCEbXj5O8cwbZdyrtQ$4RkxTGl3xkEfm51P/gc3FORCysPStozAsm6smOnQR18', + null, null, 'weichun@example.com', true, true, true, true); + insert into user_roles (user_id, roles) values (1, 'USER'); insert into user_roles (user_id, roles) +values (2, 'USER'); +insert into user_roles (user_id, roles) values (1, 'ADMIN'); insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) values (1,1,'IPhone13','electronic',true,'ggggg',1057088,null,3,1500,"2023-11-04 19:45:00",null,null,null); + + + /* insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) values (1,2,'IPhone18','electronic',true,'ggggg',1057088,null,3,1500,"2023-11-04 19:45:00",null,null,null); - +*/ insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) values (1,3,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,4,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); -*/ \ No newline at end of file +values (1,4,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 18:45:00",1000,null); From 2878c08b94a96050b916c1be5d7bf546bf0a3090 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 26 Nov 2023 17:42:15 +0800 Subject: [PATCH 056/163] feat: "Regularly check if the auction has ended." --- .../spring/NtouAuctionJavaApplication.java | 2 ++ .../spring/data/service/ProductService.java | 10 +++---- .../spring/data/service/TimerTask.java | 27 +++++++++++++++++++ src/main/resources/data.sql | 2 +- 4 files changed, 35 insertions(+), 6 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/data/service/TimerTask.java diff --git a/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java b/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java index ed9e574..c032e2d 100644 --- a/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java +++ b/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java @@ -6,10 +6,12 @@ import org.springframework.boot.autoconfigure.sql.init.SqlDataSourceScriptDatabaseInitializer; import org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties; import org.springframework.context.annotation.Bean; +import org.springframework.scheduling.annotation.EnableScheduling; import javax.sql.DataSource; @SpringBootApplication +@EnableScheduling public class NtouAuctionJavaApplication { public static void main(String[] args) { diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index ad67c43..e18b508 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -12,12 +12,9 @@ public class ProductService { private final ProductRepository repository; - private final UserIdentity userIdentity; - private final UserService userService; - public ProductService(ProductRepository repository, UserIdentity userIdentity, UserService userService) { + + public ProductService(ProductRepository repository) { this.repository = repository; - this.userIdentity = userIdentity; - this.userService = userService; } public Product get(String productName) { @@ -80,4 +77,7 @@ public List findByProductClassification(String productType){ return repository.findAllByProductType(productType); } + public List findByProductNonFixed(){ + return repository.findAllByIsFixedPriceFalse(); + } } diff --git a/src/main/java/ntou/auction/spring/data/service/TimerTask.java b/src/main/java/ntou/auction/spring/data/service/TimerTask.java new file mode 100644 index 0000000..6a02a02 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/TimerTask.java @@ -0,0 +1,27 @@ +package ntou.auction.spring.data.service; + +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Component; +import ntou.auction.spring.data.entity.Product; + +import java.util.List; +@Component +public class TimerTask { + + private final ProductService productService; + + public TimerTask(ProductService productService) { + this.productService = productService; + } + + @Scheduled(cron = "0 * * * * ?") //每分鐘的第0秒 + public void execute() { + List productList = productService.findByProductNonFixed(); + + for (Product product : productList) { + if (product.isExpired()) { + System.out.println("這個id = "+product.getId() + "的商品競標結束了"); + } + } + } +} diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 39aafd2..8f755b0 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -31,4 +31,4 @@ insert into product (version,id,product_name,product_type,is_fixed_price,product values (1,3,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,4,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 18:45:00",1000,null); +values (1,4,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-30 18:45:00",1000,null); From b8ac100d7668cc5d3cb8cbcfcaa82dad4d196712 Mon Sep 17 00:00:00 2001 From: Ray Date: Sun, 26 Nov 2023 21:47:05 +0800 Subject: [PATCH 057/163] feat: add a parameter of amount when adding a product --- .../controller/ShoppingcartController.java | 23 +++++++++++-------- .../spring/data/entity/Shoppingcart.java | 13 ++++++++++- .../data/entity/ShoppingcartRequest.java | 2 ++ .../data/service/ShoppingcartService.java | 18 +++++++++++---- 4 files changed, 42 insertions(+), 14 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index d69c5f8..82e14d3 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -39,17 +39,12 @@ public ShoppingcartController(ShoppingcartService shoppingcartService, ProductSe @GetMapping("/shoppingcart") @ResponseBody List getShoppingcartProfile() { return shoppingcartService.list(); } - @GetMapping("/{userId}") - @ResponseBody - Shoppingcart getUserShoppingcart(@PathVariable long userId) { - return shoppingcartService.getByUserId(userId); - } @GetMapping("/view") @ResponseBody List getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); - Shoppingcart userShoppingcart = getUserShoppingcart(userId); + Shoppingcart userShoppingcart = shoppingcartService.getByUserId(userId); if(userShoppingcart==null) return null; List result = new ArrayList<>(); for(Map.Entry product: userShoppingcart.getProductItems().entrySet()) { @@ -61,23 +56,33 @@ List getProduct() { ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); - shoppingcartService.addProductByUserId(userId, addProductId); + Long amount = request.getAmount(); + shoppingcartService.addProductByUserId(userId, addProductId, amount==null?1L:amount); return ResponseEntity.ok(successMessage); } + @DeleteMapping("/decrease") + ResponseEntity> decreaseProduct(@Valid @RequestBody ShoppingcartRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long addProductId = request.getProductId(); + Long amount = request.getAmount(); + boolean result = shoppingcartService.decreaseProductByUserId(userId, addProductId, amount==null?1L:amount); + return (result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(failMessage)); + } + @DeleteMapping("/delete") ResponseEntity> deleteProduct(@Valid @RequestBody ShoppingcartRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); boolean result = shoppingcartService.deleteProductByUserId(userId, addProductId); - return (result?ResponseEntity.ok(successMessage):ResponseEntity.ok(failMessage)); + return (result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(failMessage)); } @DeleteMapping("/deleteall") ResponseEntity> deleteAllProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); boolean result = shoppingcartService.deleteShoppingcartByUserId(userId); - if(!result) return ResponseEntity.ok(failMessage); + if(!result) return ResponseEntity.badRequest().body(failMessage); return ResponseEntity.ok(successMessage); } } diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java index de7f03b..cb0f8a4 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -31,14 +31,25 @@ public void addProductId(Long product, Long amount) { productItems.replace(product, productItems.get(product)+amount); } - public boolean deleteProduct(Long product, Long amount) { + public boolean decreaseProduct(Long product, Long amount) { if (productItems.get(product) == null) return false; if (productItems.get(product) == 0L) { productItems.remove(product); return false; } + if(productItems.get(product) < amount) return false; productItems.replace(product, productItems.get(product) - amount); if (productItems.get(product) == 0L) productItems.remove(product); return true; } + + public boolean deleteProduct(Long product) { + if (productItems.get(product) == null) return false; + if (productItems.get(product) == 0L) { + productItems.remove(product); + return false; + } + productItems.remove(product); + return true; + } } diff --git a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java index 3133711..130707d 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java +++ b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java @@ -11,4 +11,6 @@ public class ShoppingcartRequest { @NotNull private Long productId; + + private Long amount; } diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java index 77b60e4..eada01d 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -41,7 +41,7 @@ public boolean deleteShoppingcartByUserId(Long userId) { return true; } - public void addProductByUserId(Long userId, Long productId) { + public void addProductByUserId(Long userId, Long productId, Long amount) { Shoppingcart userShoppingcart = getByUserId(userId); if (userShoppingcart == null) { Map product = new HashMap<>(); @@ -49,17 +49,27 @@ public void addProductByUserId(Long userId, Long productId) { repository.save(newShoppingcart); userShoppingcart = getByUserId(userId); } - userShoppingcart.addProductId(productId, 1L); + userShoppingcart.addProductId(productId, amount); repository.save(userShoppingcart); } - public boolean deleteProductByUserId(Long userId, Long productId) { + public boolean decreaseProductByUserId(Long userId, Long productId, Long amount) { Shoppingcart userShoppingcart = getByUserId(userId); if (userShoppingcart == null) return false; - boolean result = userShoppingcart.deleteProduct(productId, 1L); + boolean result = userShoppingcart.decreaseProduct(productId, amount); if (!result) return false; repository.save(userShoppingcart); if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); return true; } + + public boolean deleteProductByUserId(Long userId, Long productId) { + Shoppingcart userShoppingcart = getByUserId(userId); + if (userShoppingcart == null) return false; + boolean result = userShoppingcart.deleteProduct(productId); + if(!result) return false; + repository.save(userShoppingcart); + if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); + return true; + } } From 0cbf2e3bfb3fff5bb777ee923dec0c8f033d89a8 Mon Sep 17 00:00:00 2001 From: Ray Date: Sun, 26 Nov 2023 22:19:06 +0800 Subject: [PATCH 058/163] feat: add ProductClassificatedBySeller class, which would show products classificated by seller when calling view function --- .../controller/ShoppingcartController.java | 8 +++---- .../entity/ProductClassificatedBySeller.java | 24 +++++++++++++++++++ 2 files changed, 28 insertions(+), 4 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 82e14d3..3cc0844 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -1,7 +1,7 @@ package ntou.auction.spring.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.ProductAddAmount; +import ntou.auction.spring.data.entity.ProductClassificatedBySeller; import ntou.auction.spring.data.entity.Shoppingcart; import ntou.auction.spring.data.entity.ShoppingcartRequest; import ntou.auction.spring.data.service.ProductService; @@ -42,13 +42,13 @@ public ShoppingcartController(ShoppingcartService shoppingcartService, ProductSe @GetMapping("/view") @ResponseBody - List getProduct() { + ProductClassificatedBySeller getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Shoppingcart userShoppingcart = shoppingcartService.getByUserId(userId); if(userShoppingcart==null) return null; - List result = new ArrayList<>(); + ProductClassificatedBySeller result = new ProductClassificatedBySeller(); for(Map.Entry product: userShoppingcart.getProductItems().entrySet()) { - result.add(new ProductAddAmount(productService.getID(product.getKey()), product.getValue())); + result.addProduct(productService.getID(product.getKey()), product.getValue()); } return result; } diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java b/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java new file mode 100644 index 0000000..9a36ad3 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java @@ -0,0 +1,24 @@ +package ntou.auction.spring.data.entity; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Getter +@NoArgsConstructor +@AllArgsConstructor +public class ProductClassificatedBySeller { + private Map> ProductShowBySeller = new HashMap<>(); + public void addProduct(Product product, Long amount) { + String seller = product.getSeller(); + if(!ProductShowBySeller.containsKey(seller)) ProductShowBySeller.put(seller, new ArrayList<>()); + List getProducts = ProductShowBySeller.get(seller); + getProducts.add(new ProductAddAmount(product, amount)); + ProductShowBySeller.replace(seller, getProducts); + } +} From 33e57143a32aa33bd653b89c350577b052523c7a Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:48:31 +0800 Subject: [PATCH 059/163] chore: Add Spring Websocket dependency for chat feature. --- pom.xml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pom.xml b/pom.xml index fb80fdb..4edf49b 100644 --- a/pom.xml +++ b/pom.xml @@ -66,6 +66,11 @@ jjwt-api 0.12.3 + + + org.springframework.boot + spring-boot-starter-websocket + io.jsonwebtoken jjwt-impl From 4649d96b093d77f38423bd864d48490d0f7335ea Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:53:24 +0800 Subject: [PATCH 060/163] feat: Add entity class for chat-related functionality. --- .../spring/chat/data/entity/ChatMessage.java | 25 +++++++++++++++++++ .../chat/data/entity/ChatMessageStatus.java | 5 ++++ .../chat/data/entity/ChatNotification.java | 15 +++++++++++ .../spring/chat/data/entity/ChatRoom.java | 16 ++++++++++++ 4 files changed, 61 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java new file mode 100644 index 0000000..17107ee --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java @@ -0,0 +1,25 @@ +package ntou.auction.spring.chat.data.entity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import jakarta.persistence.Entity; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; +import java.time.LocalDateTime; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ChatMessage extends AbstractEntity { + private Long senderId; + private Long receiverId; + private String senderUserName; + private String receiverUserName; + private Long chatId; + private String content; + @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") + private LocalDateTime timestamp; + private ChatMessageStatus chatMessageStatus; +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java new file mode 100644 index 0000000..2d9ef65 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java @@ -0,0 +1,5 @@ +package ntou.auction.spring.chat.data.entity; + +public enum ChatMessageStatus { + RECEIVED, DELIVERED +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java new file mode 100644 index 0000000..477d19a --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java @@ -0,0 +1,15 @@ +package ntou.auction.spring.chat.data.entity; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class ChatNotification extends AbstractEntity { + private Long id; + private Long senderId; + private String senderName; +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java new file mode 100644 index 0000000..3de0d92 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java @@ -0,0 +1,16 @@ +package ntou.auction.spring.chat.data.entity; + +import jakarta.persistence.Entity; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ChatRoom extends AbstractEntity { + private Long chatId; + private Long senderId; + private Long receiverId; +} From 9b1488156b8e5b3632030eb7af56f96df6cba9d4 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:54:30 +0800 Subject: [PATCH 061/163] feat: Add repository class for chat-related functionality. --- .../repository/ChatMessageRepository.java | 23 +++++++++++++++++++ .../chat/repository/ChatRoomRepository.java | 15 ++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java create mode 100644 src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java new file mode 100644 index 0000000..e33149b --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java @@ -0,0 +1,23 @@ +package ntou.auction.spring.chat.repository; + + +import jakarta.validation.constraints.NotNull; +import ntou.auction.spring.chat.data.entity.ChatMessageStatus; +import ntou.auction.spring.chat.data.entity.ChatMessage; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Query; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface ChatMessageRepository extends JpaRepository, JpaSpecificationExecutor { + + List findByChatId(@NotNull Long chatId); + + List findBySenderIdAndReceiverId(Long senderId, Long receiverId); + + Long countBySenderIdAndReceiverIdAndAndChatMessageStatus(Long senderId, Long receiverId, ChatMessageStatus ChatMessageStatus); + +} diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java new file mode 100644 index 0000000..e40289d --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java @@ -0,0 +1,15 @@ +package ntou.auction.spring.chat.repository; + +import ntou.auction.spring.chat.data.entity.ChatRoom; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.stereotype.Repository; + +import java.util.Optional; + +@Repository +public interface ChatRoomRepository extends JpaRepository, + JpaSpecificationExecutor { + + Optional findChatRoomBySenderIdAndReceiverId(Long senderId, Long receiverId); +} From f62235db00aa41b8bd8aaca4eaad92390e10b455 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:55:27 +0800 Subject: [PATCH 062/163] feat: Add service class for chat-related functionality. --- .../chat/data/service/ChatMessageService.java | 70 +++++++++++++++++++ .../chat/data/service/ChatRoomService.java | 43 ++++++++++++ 2 files changed, 113 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java new file mode 100644 index 0000000..2093f4d --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java @@ -0,0 +1,70 @@ +package ntou.auction.spring.chat.data.service; + +import ntou.auction.spring.chat.data.entity.ChatMessage; +import ntou.auction.spring.chat.data.entity.ChatMessageStatus; +import ntou.auction.spring.chat.exception.MessageNotFound; +import ntou.auction.spring.chat.repository.ChatMessageRepository; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +@Service +public class ChatMessageService { + private final ChatMessageRepository repository; + private final ChatRoomService chatRoomService; + + + public ChatMessageService(ChatMessageRepository repository, ChatRoomService chatRoomService) { + this.repository = repository; + this.chatRoomService = chatRoomService; + } + + public ChatMessage save(ChatMessage chatMessage) { + chatMessage.setChatMessageStatus(ChatMessageStatus.RECEIVED); + repository.save(chatMessage); + return chatMessage; + } + + public Long countNewMessages(Long senderId, Long receiverId) { + return repository.countBySenderIdAndReceiverIdAndAndChatMessageStatus( + senderId, receiverId, ChatMessageStatus.RECEIVED); + } + + public List findChatMessages(Long senderId, Long receiverId) { + Optional chatId = chatRoomService.getChatId(senderId, receiverId, false); + + if(chatId.isEmpty()){ + return new ArrayList<>(); + } + + List messages = + chatId.map(repository::findByChatId).orElse(new ArrayList<>()); + + if(!messages.isEmpty()) { + updateStatuses(senderId, receiverId, ChatMessageStatus.DELIVERED); + } + + return messages; + } + + public ChatMessage findById(Long id) { + return repository + .findById(id) + .map(chatMessage -> { + chatMessage.setChatMessageStatus(ChatMessageStatus.DELIVERED); + return repository.save(chatMessage); + }) + .orElseThrow(() -> + new MessageNotFound("無法找到 ID為 " + id + " 的聊天紀錄")); + } + + public void updateStatuses(Long senderId, Long receiverId, ChatMessageStatus status) { + List chatMessages = repository.findBySenderIdAndReceiverId(senderId,receiverId); + for(ChatMessage chatMessage:chatMessages){ + chatMessage.setChatMessageStatus(status); + repository.save(chatMessage); + } + } +} diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java new file mode 100644 index 0000000..6252856 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java @@ -0,0 +1,43 @@ +package ntou.auction.spring.chat.data.service; + +import ntou.auction.spring.chat.data.entity.ChatRoom; +import ntou.auction.spring.chat.repository.ChatRoomRepository; +import org.springframework.stereotype.Service; + +import java.util.Optional; + +@Service +public class ChatRoomService { + private final ChatRoomRepository repository; + + public ChatRoomService(ChatRoomRepository chatRoomRepository) { + this.repository = chatRoomRepository; + } + + public Optional getChatId(Long senderId, Long receiverId, boolean createIfNotExist) { + + return repository.findChatRoomBySenderIdAndReceiverId(senderId, receiverId).map(ChatRoom::getChatId).or(() -> { + if (!createIfNotExist) { + return Optional.empty(); + } + + String chatId = String.format("%s%s", senderId, receiverId); + + ChatRoom senderRecipient = new ChatRoom(); + senderRecipient.setChatId(Long.parseLong(chatId)); + senderRecipient.setSenderId(senderId); + senderRecipient.setReceiverId(receiverId); + + repository.save(senderRecipient); + + ChatRoom recipientSender = new ChatRoom(); + recipientSender.setChatId(Long.parseLong(chatId)); + recipientSender.setSenderId(receiverId); + recipientSender.setReceiverId(senderId); + + repository.save(recipientSender); + + return Optional.of(Long.parseLong(chatId)); + }); + } +} From 9218e521b9f17b8b26ba069ca743b4af10869272 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:55:58 +0800 Subject: [PATCH 063/163] feat: Add API controller class for chat-related functionality. --- .../chat/controller/ChatController.java | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/controller/ChatController.java diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java new file mode 100644 index 0000000..adf76b2 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -0,0 +1,97 @@ +package ntou.auction.spring.chat.controller; + + +import ntou.auction.spring.chat.data.entity.ChatMessage; +import ntou.auction.spring.chat.data.entity.ChatNotification; +import ntou.auction.spring.chat.data.service.ChatMessageService; +import ntou.auction.spring.chat.data.service.ChatRoomService; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; +import org.springframework.http.ResponseEntity; +import org.springframework.messaging.handler.annotation.MessageMapping; +import org.springframework.messaging.handler.annotation.Payload; +import org.springframework.messaging.simp.SimpMessagingTemplate; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; + +import java.security.Principal; +import java.time.LocalDateTime; +import java.util.Optional; + +@Controller +@CrossOrigin(origins = "http://localhost:3000") +public class ChatController { + + private final UserService userService; + + private final UserIdentity userIdentity; + + private final SimpMessagingTemplate messageTemplate; + private final ChatMessageService chatMessageService; + private final ChatRoomService chatRoomService; + + public ChatController(UserService userService, UserIdentity userIdentity, SimpMessagingTemplate messageTemplate, ChatMessageService chatMessageService, ChatRoomService chatRoomService) { + this.userService = userService; + this.userIdentity = userIdentity; + this.messageTemplate = messageTemplate; + this.chatMessageService = chatMessageService; + this.chatRoomService = chatRoomService; + } + + @MessageMapping("/send") + public void sendMessage(@Payload ChatMessage chatMessage, Principal principal) { + /* + User sender = userService.findByUsername(userIdentity.getUsername()); + ChatMessage message = new ChatMessage(); + message.setSenderId(sender.getId()); + message.setReceiverId(chatMessageRequest.getReceiverId()); + message.setContent(chatMessageRequest.getContent()); + */ + + // token無效 + if (principal.getName() == null) { + return; + } + // 傳給不存在的使用者 + if (userService.get(chatMessage.getReceiverId()).isEmpty()) { + return; + } + + Optional chatId = chatRoomService.getChatId(userService.findByUsername(principal.getName()).getId(), chatMessage.getReceiverId(), true); + System.out.println(chatId); + chatId.ifPresent(chatMessage::setChatId); + chatMessage.setSenderId(userService.findByUsername(principal.getName()).getId()); + chatMessage.setTimestamp(LocalDateTime.now()); + chatMessage.setSenderUserName(principal.getName()); + chatMessage.setReceiverUserName(userService.get(chatMessage.getReceiverId()).get().getUsername()); + ChatMessage saved = chatMessageService.save(chatMessage); + + messageTemplate.convertAndSendToUser(saved.getReceiverId().toString(), "/queue/messages", new ChatNotification( + saved.getId(), + saved.getSenderId(), + principal.getName() + )); + } + + @GetMapping("/api/v1/chat/message/{id}") + public ResponseEntity findMessage(@PathVariable Long id) { + return ResponseEntity + .ok(chatMessageService.findById(id)); + } + + @GetMapping("/api/v1/chat/messages/{recipientId}/count") + public ResponseEntity countNewMessages( + @PathVariable String recipientId) { + return ResponseEntity + .ok(chatMessageService.countNewMessages(userService.findByUsername(userIdentity.getUsername()).getId(), Long.parseLong(recipientId))); + } + + @GetMapping("/api/v1/chat/messages/{recipientId}") + public ResponseEntity findChatMessages( + @PathVariable Long recipientId) { + return ResponseEntity + .ok(chatMessageService.findChatMessages(userService.findByUsername(userIdentity.getUsername()).getId(), recipientId)); + } +} From 1680f42aaf324fa171e0333b63b48935b2e95f9c Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:58:09 +0800 Subject: [PATCH 064/163] feat: Add config class for chat-related functionality. --- .../chat/config/AuthChannelInterceptor.java | 60 ++++++++++++++++++ .../spring/chat/config/WebSocketConfig.java | 62 +++++++++++++++++++ 2 files changed, 122 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java create mode 100644 src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java diff --git a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java new file mode 100644 index 0000000..82243f7 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java @@ -0,0 +1,60 @@ +package ntou.auction.spring.chat.config; + +import io.micrometer.common.util.StringUtils; +import ntou.auction.spring.security.JWTService; +import ntou.auction.spring.security.UserDetailsServiceImpl; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; +import org.springframework.messaging.Message; +import org.springframework.messaging.MessageChannel; +import org.springframework.messaging.simp.stomp.StompCommand; +import org.springframework.messaging.simp.stomp.StompHeaderAccessor; +import org.springframework.messaging.support.ChannelInterceptor; +import org.springframework.messaging.support.MessageHeaderAccessor; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.stereotype.Component; + +import java.util.List; + +@Component +@Order(Ordered.HIGHEST_PRECEDENCE + 99) +public class AuthChannelInterceptor implements ChannelInterceptor { + + private final UserDetailsServiceImpl userDetailsServiceImpl; + + public AuthChannelInterceptor(UserDetailsServiceImpl userDetailsServiceImpl) { + this.userDetailsServiceImpl = userDetailsServiceImpl; + } + + @Override + public Message preSend(Message message, MessageChannel channel) { + StompHeaderAccessor accessor = + MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); + // 第一次連線 + if (accessor != null && StompCommand.CONNECT.equals(accessor.getCommand())) { + // 驗證token + List header = accessor.getNativeHeader("Authorization"); + // header裡面有沒有token + if (header != null && !header.isEmpty()) { + String token = header.get(0); + if (StringUtils.isNotBlank(token)) { + String username = JWTService.validateTokenAndGetUsername(token); + System.out.println("username:" + username); + // token有效 + if (username != null) { + UserDetails userDetails = userDetailsServiceImpl.loadUserByUsername(username); + Authentication authentication = + new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword()); + accessor.setUser(authentication); + return message; + } + } + } + } + System.out.println("message:" + message); + // 非第一次連線，不用驗證 + return message; + } +} diff --git a/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java b/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java new file mode 100644 index 0000000..fcba044 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java @@ -0,0 +1,62 @@ +package ntou.auction.spring.chat.config; + +import com.fasterxml.jackson.databind.ObjectMapper; +import ntou.auction.spring.security.UserDetailsServiceImpl; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; +import org.springframework.messaging.converter.DefaultContentTypeResolver; +import org.springframework.messaging.converter.MappingJackson2MessageConverter; +import org.springframework.messaging.converter.MessageConverter; +import org.springframework.messaging.simp.config.ChannelRegistration; +import org.springframework.messaging.simp.config.MessageBrokerRegistry; +import org.springframework.util.MimeTypeUtils; +import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker; +import org.springframework.web.socket.config.annotation.StompEndpointRegistry; +import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; + +import java.util.List; + +@Configuration +@EnableWebSocketMessageBroker +public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { + + private final AuthChannelInterceptor authChannelInterceptor; + + public WebSocketConfig(AuthChannelInterceptor authChannelInterceptor) { + this.authChannelInterceptor = authChannelInterceptor; + } + + @Override + public void configureMessageBroker(MessageBrokerRegistry config) { + // server端推送給client端 + config.enableSimpleBroker("/user"); + // client端發送給server端 + config.setApplicationDestinationPrefixes("/app"); + config.setUserDestinationPrefix("/user"); + } + + @Override + public void registerStompEndpoints(StompEndpointRegistry registry) { + registry.addEndpoint("/ws") + .setAllowedOrigins("*"); + //.withSockJS(); + } + + @Override + public boolean configureMessageConverters(List messageConverters) { + DefaultContentTypeResolver resolver = new DefaultContentTypeResolver(); + resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON); + MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(); + converter.setObjectMapper(new ObjectMapper()); + converter.setContentTypeResolver(resolver); + messageConverters.add(converter); + return false; + } + + @Override + public void configureClientInboundChannel(ChannelRegistration registration) { + registration.interceptors(authChannelInterceptor); + } + +} From 398042889668e94b43d2e1ce69775eb8f2d4c2cd Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 01:01:38 +0800 Subject: [PATCH 065/163] feat: Update security configuration to allow WebSocket connections. --- .../ntou/auction/spring/security/SecurityConfiguration.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index d3266f5..cdceb7d 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -70,7 +70,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .csrf(AbstractHttpConfigurer::disable) .cors(AbstractHttpConfigurer::disable) .authorizeHttpRequests(authorize -> authorize - .requestMatchers( "/api/v1/test/**").permitAll() + .requestMatchers("/api/v1/test/**").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/sign-up").permitAll() .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() @@ -80,6 +80,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) .requestMatchers( HttpMethod.GET,"/api/v1/product/**").permitAll() .requestMatchers( HttpMethod.POST,"/api/v1/product/**").permitAll() + .requestMatchers("/ws/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session @@ -88,7 +89,6 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { return http.build(); } - @Bean public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception { return authenticationConfiguration.getAuthenticationManager(); From 90a9d68991a7481466b8e459edd9f729274ad076 Mon Sep 17 00:00:00 2001 From: Ray Date: Thu, 23 Nov 2023 21:48:13 +0800 Subject: [PATCH 066/163] feat: add Shoppingcart entity --- .../spring/data/entity/Shoppingcart.java | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java new file mode 100644 index 0000000..1629ba5 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -0,0 +1,35 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.*; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import java.util.ArrayList; +import java.util.List; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +@Table(name = "shoppingcart") +public class Shoppingcart extends AbstractEntity { + + @NotNull + private Long userid; + + @ElementCollection + @CollectionTable(name = "productId") + private List productId = new ArrayList<>(); + + public @NotNull Long getUserId() { + return userid; + } + public void addProductId(Long product) { + productId.add(product); + } + + public boolean deleteProduct(Long product) { + return productId.remove(product); + } +} From 37fe5e6a064383e227fec484382d8e26a24a1789 Mon Sep 17 00:00:00 2001 From: Ray Date: Thu, 23 Nov 2023 21:50:26 +0800 Subject: [PATCH 067/163] feat: introduce Shoppingcart service --- .../data/service/ShoppingcartRepository.java | 24 ++++++++ .../data/service/ShoppingcartService.java | 61 +++++++++++++++++++ 2 files changed, 85 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java create mode 100644 src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java new file mode 100644 index 0000000..6620533 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java @@ -0,0 +1,24 @@ +package ntou.auction.spring.data.service; + +import jakarta.transaction.Transactional; +import ntou.auction.spring.data.entity.Shoppingcart; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Modifying; +import org.springframework.data.jpa.repository.Query; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public interface ShoppingcartRepository extends JpaRepository, JpaSpecificationExecutor { + @Modifying + @Query(value = "insert into shoppingcart(userId, productId) values (?1, ?2)", nativeQuery = true) + public void addShoppingCart(Long userId, List productId); + + Shoppingcart findById(long id); + //@Query(value = "select s from Shoppingcart s where s.id = ?1") + Optional findByUserid(Long id); + @Transactional + public List deleteByUserid(Long UserId); +} diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java new file mode 100644 index 0000000..b532596 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -0,0 +1,61 @@ +package ntou.auction.spring.data.service; + +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.Shoppingcart; +import org.springframework.stereotype.Service; + +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.List; + +@Service +public class ShoppingcartService { + private final ShoppingcartRepository repository; + + public ShoppingcartService(ShoppingcartRepository repository) { + this.repository = repository; + } + + public Shoppingcart getByUserId(Long userId) { + return repository.findByUserid(userId).orElse(null); + } + + public List list() { + return repository.findAll(); + } + + public void addUser(Long userId) { + List product = new ArrayList<>(); + repository.addShoppingCart(userId, product); + } + + public int count() { + return (int) repository.count(); + } + + public boolean deleteShoppingcartByUserId(Long userId) { + if(repository.findByUserid(userId).isEmpty()) return false; + repository.deleteByUserid(userId); + return true; + } + + public void addProductByUserId(Long userId, Long productId) { + Shoppingcart userShoppingcart = getByUserId(userId); + if(userShoppingcart==null) { + List product = new ArrayList<>(); + Shoppingcart newShoppingcart = new Shoppingcart(userId, product); + repository.save(newShoppingcart); + userShoppingcart = getByUserId(userId); + } + userShoppingcart.addProductId(productId); + repository.save(userShoppingcart); + } + + public boolean deleteProductByUserId(Long userId, Long productId) { + Shoppingcart userShoppingcart = getByUserId(userId); + boolean result = userShoppingcart.deleteProduct(productId); + if(!result) return false; + repository.save(userShoppingcart); + return true; + } +} From 2cd192bdf428941dfe1937f94e4f9738c75ad59e Mon Sep 17 00:00:00 2001 From: Ray Date: Thu, 23 Nov 2023 21:54:57 +0800 Subject: [PATCH 068/163] feat: Introduce a REST Controller for Shoppingcart with error handling. --- .../controller/ShoppingcartController.java | 83 +++++++++++++++++++ .../data/entity/ShoppingcartRequest.java | 14 ++++ 2 files changed, 97 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/controller/ShoppingcartController.java create mode 100644 src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java new file mode 100644 index 0000000..7c08646 --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -0,0 +1,83 @@ +package ntou.auction.spring.controller; + +import jakarta.validation.Valid; +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.Shoppingcart; +import ntou.auction.spring.data.entity.ShoppingcartRequest; +import ntou.auction.spring.data.service.ProductService; +import ntou.auction.spring.data.service.ShoppingcartService; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +@RestController +@RequestMapping(value = "/api/v1/shoppingcart", produces = MediaType.APPLICATION_JSON_VALUE) +@CrossOrigin(origins = "http://localhost:3000") +public class ShoppingcartController { + private final ShoppingcartService shoppingcartService; + private final ProductService productService; + private static final Map successMessage = Collections.singletonMap("message","成功"); + private static final Map failMessage = Collections.singletonMap("message","好像發生了什麼錯誤，請檢查一下腦袋"); + + private final UserService userService; + + private final UserIdentity userIdentity; + + public ShoppingcartController(ShoppingcartService shoppingcartService, ProductService productService, UserService userService, UserIdentity userIdentity) { + this.shoppingcartService = shoppingcartService; + this.productService = productService; + this.userService = userService; + this.userIdentity = userIdentity; + } + @GetMapping("/shoppingcart") + @ResponseBody + List getShoppingcartProfile() { return shoppingcartService.list(); } + @GetMapping("/{userId}") + @ResponseBody + Shoppingcart getUserShoppingcart(@PathVariable long userId) { + return shoppingcartService.getByUserId(userId); + } + + @GetMapping("/view") + @ResponseBody + List getProduct() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Shoppingcart userShoppingcart = getUserShoppingcart(userId); + if(userShoppingcart==null) return null; + List result = new ArrayList<>(); + for(Long productId: userShoppingcart.getProductId()) { + result.add(productService.getID(productId)); + } + return result; + } + @PostMapping("/add") + ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long addProductId = request.getProductId(); + shoppingcartService.addProductByUserId(userId, addProductId); + return ResponseEntity.ok(successMessage); + } + + @DeleteMapping("/delete") + ResponseEntity> deleteProduct(@Valid @RequestBody ShoppingcartRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long addProductId = request.getProductId(); + boolean result = shoppingcartService.deleteProductByUserId(userId, addProductId); + return (result?ResponseEntity.ok(successMessage):ResponseEntity.ok(failMessage)); + } + + @DeleteMapping("/deleteall") + ResponseEntity> deleteAllProduct() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + boolean result = shoppingcartService.deleteShoppingcartByUserId(userId); + if(!result) return ResponseEntity.ok(failMessage); + return ResponseEntity.ok(successMessage); + } +} diff --git a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java new file mode 100644 index 0000000..3133711 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java @@ -0,0 +1,14 @@ +package ntou.auction.spring.data.entity; + +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ShoppingcartRequest { + @NotNull + private Long productId; +} From 0dcc30e7ae764171a37063c0af48d0b9a249b13d Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 24 Nov 2023 00:01:53 +0800 Subject: [PATCH 069/163] feat: add parameter of amount to Shoppingcart --- .../spring/data/entity/Shoppingcart.java | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java index 1629ba5..de7f03b 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -5,8 +5,8 @@ import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import java.util.ArrayList; -import java.util.List; +import java.util.HashMap; +import java.util.Map; @Entity @Data @@ -20,16 +20,25 @@ public class Shoppingcart extends AbstractEntity { @ElementCollection @CollectionTable(name = "productId") - private List productId = new ArrayList<>(); + private Map productItems = new HashMap<>(); public @NotNull Long getUserId() { return userid; } - public void addProductId(Long product) { - productId.add(product); + + public void addProductId(Long product, Long amount) { + if(!productItems.containsKey(product)) productItems.put(product, 0L); + productItems.replace(product, productItems.get(product)+amount); } - public boolean deleteProduct(Long product) { - return productId.remove(product); + public boolean deleteProduct(Long product, Long amount) { + if (productItems.get(product) == null) return false; + if (productItems.get(product) == 0L) { + productItems.remove(product); + return false; + } + productItems.replace(product, productItems.get(product) - amount); + if (productItems.get(product) == 0L) productItems.remove(product); + return true; } } From c2901c2086fd20c60b769df27e630088932252bb Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 24 Nov 2023 00:08:50 +0800 Subject: [PATCH 070/163] feat: merge shoppingcart and development --- .../controller/ShoppingcartController.java | 10 +++++----- .../spring/data/service/ShoppingcartService.java | 16 ++++++++++------ 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 7c08646..d69c5f8 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -1,7 +1,7 @@ package ntou.auction.spring.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.ProductAddAmount; import ntou.auction.spring.data.entity.Shoppingcart; import ntou.auction.spring.data.entity.ShoppingcartRequest; import ntou.auction.spring.data.service.ProductService; @@ -47,13 +47,13 @@ Shoppingcart getUserShoppingcart(@PathVariable long userId) { @GetMapping("/view") @ResponseBody - List getProduct() { + List getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Shoppingcart userShoppingcart = getUserShoppingcart(userId); if(userShoppingcart==null) return null; - List result = new ArrayList<>(); - for(Long productId: userShoppingcart.getProductId()) { - result.add(productService.getID(productId)); + List result = new ArrayList<>(); + for(Map.Entry product: userShoppingcart.getProductItems().entrySet()) { + result.add(new ProductAddAmount(productService.getID(product.getKey()), product.getValue())); } return result; } diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java index b532596..77b60e4 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -6,7 +6,9 @@ import java.lang.reflect.Array; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; @Service public class ShoppingcartService { @@ -34,28 +36,30 @@ public int count() { } public boolean deleteShoppingcartByUserId(Long userId) { - if(repository.findByUserid(userId).isEmpty()) return false; + if (repository.findByUserid(userId).isEmpty()) return false; repository.deleteByUserid(userId); return true; } public void addProductByUserId(Long userId, Long productId) { Shoppingcart userShoppingcart = getByUserId(userId); - if(userShoppingcart==null) { - List product = new ArrayList<>(); + if (userShoppingcart == null) { + Map product = new HashMap<>(); Shoppingcart newShoppingcart = new Shoppingcart(userId, product); repository.save(newShoppingcart); userShoppingcart = getByUserId(userId); } - userShoppingcart.addProductId(productId); + userShoppingcart.addProductId(productId, 1L); repository.save(userShoppingcart); } public boolean deleteProductByUserId(Long userId, Long productId) { Shoppingcart userShoppingcart = getByUserId(userId); - boolean result = userShoppingcart.deleteProduct(productId); - if(!result) return false; + if (userShoppingcart == null) return false; + boolean result = userShoppingcart.deleteProduct(productId, 1L); + if (!result) return false; repository.save(userShoppingcart); + if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); return true; } } From a2436c351fc870ef9bdac5645a7056c1b71f0664 Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 24 Nov 2023 00:09:40 +0800 Subject: [PATCH 071/163] feat: add ProductAddAmount class --- .../auction/spring/data/entity/ProductAddAmount.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java b/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java new file mode 100644 index 0000000..4366945 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java @@ -0,0 +1,12 @@ +package ntou.auction.spring.data.entity; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +@Getter +@NoArgsConstructor +@AllArgsConstructor +public class ProductAddAmount{ + private Product product; + private Long amount; +} From df15840feabe22b012e6587de8253373fb57b56a Mon Sep 17 00:00:00 2001 From: Ray Date: Sun, 26 Nov 2023 21:47:05 +0800 Subject: [PATCH 072/163] feat: add a parameter of amount when adding a product --- .../controller/ShoppingcartController.java | 23 +++++++++++-------- .../spring/data/entity/Shoppingcart.java | 13 ++++++++++- .../data/entity/ShoppingcartRequest.java | 2 ++ .../data/service/ShoppingcartService.java | 18 +++++++++++---- 4 files changed, 42 insertions(+), 14 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index d69c5f8..82e14d3 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -39,17 +39,12 @@ public ShoppingcartController(ShoppingcartService shoppingcartService, ProductSe @GetMapping("/shoppingcart") @ResponseBody List getShoppingcartProfile() { return shoppingcartService.list(); } - @GetMapping("/{userId}") - @ResponseBody - Shoppingcart getUserShoppingcart(@PathVariable long userId) { - return shoppingcartService.getByUserId(userId); - } @GetMapping("/view") @ResponseBody List getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); - Shoppingcart userShoppingcart = getUserShoppingcart(userId); + Shoppingcart userShoppingcart = shoppingcartService.getByUserId(userId); if(userShoppingcart==null) return null; List result = new ArrayList<>(); for(Map.Entry product: userShoppingcart.getProductItems().entrySet()) { @@ -61,23 +56,33 @@ List getProduct() { ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); - shoppingcartService.addProductByUserId(userId, addProductId); + Long amount = request.getAmount(); + shoppingcartService.addProductByUserId(userId, addProductId, amount==null?1L:amount); return ResponseEntity.ok(successMessage); } + @DeleteMapping("/decrease") + ResponseEntity> decreaseProduct(@Valid @RequestBody ShoppingcartRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long addProductId = request.getProductId(); + Long amount = request.getAmount(); + boolean result = shoppingcartService.decreaseProductByUserId(userId, addProductId, amount==null?1L:amount); + return (result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(failMessage)); + } + @DeleteMapping("/delete") ResponseEntity> deleteProduct(@Valid @RequestBody ShoppingcartRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); boolean result = shoppingcartService.deleteProductByUserId(userId, addProductId); - return (result?ResponseEntity.ok(successMessage):ResponseEntity.ok(failMessage)); + return (result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(failMessage)); } @DeleteMapping("/deleteall") ResponseEntity> deleteAllProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); boolean result = shoppingcartService.deleteShoppingcartByUserId(userId); - if(!result) return ResponseEntity.ok(failMessage); + if(!result) return ResponseEntity.badRequest().body(failMessage); return ResponseEntity.ok(successMessage); } } diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java index de7f03b..cb0f8a4 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -31,14 +31,25 @@ public void addProductId(Long product, Long amount) { productItems.replace(product, productItems.get(product)+amount); } - public boolean deleteProduct(Long product, Long amount) { + public boolean decreaseProduct(Long product, Long amount) { if (productItems.get(product) == null) return false; if (productItems.get(product) == 0L) { productItems.remove(product); return false; } + if(productItems.get(product) < amount) return false; productItems.replace(product, productItems.get(product) - amount); if (productItems.get(product) == 0L) productItems.remove(product); return true; } + + public boolean deleteProduct(Long product) { + if (productItems.get(product) == null) return false; + if (productItems.get(product) == 0L) { + productItems.remove(product); + return false; + } + productItems.remove(product); + return true; + } } diff --git a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java index 3133711..130707d 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java +++ b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java @@ -11,4 +11,6 @@ public class ShoppingcartRequest { @NotNull private Long productId; + + private Long amount; } diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java index 77b60e4..eada01d 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -41,7 +41,7 @@ public boolean deleteShoppingcartByUserId(Long userId) { return true; } - public void addProductByUserId(Long userId, Long productId) { + public void addProductByUserId(Long userId, Long productId, Long amount) { Shoppingcart userShoppingcart = getByUserId(userId); if (userShoppingcart == null) { Map product = new HashMap<>(); @@ -49,17 +49,27 @@ public void addProductByUserId(Long userId, Long productId) { repository.save(newShoppingcart); userShoppingcart = getByUserId(userId); } - userShoppingcart.addProductId(productId, 1L); + userShoppingcart.addProductId(productId, amount); repository.save(userShoppingcart); } - public boolean deleteProductByUserId(Long userId, Long productId) { + public boolean decreaseProductByUserId(Long userId, Long productId, Long amount) { Shoppingcart userShoppingcart = getByUserId(userId); if (userShoppingcart == null) return false; - boolean result = userShoppingcart.deleteProduct(productId, 1L); + boolean result = userShoppingcart.decreaseProduct(productId, amount); if (!result) return false; repository.save(userShoppingcart); if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); return true; } + + public boolean deleteProductByUserId(Long userId, Long productId) { + Shoppingcart userShoppingcart = getByUserId(userId); + if (userShoppingcart == null) return false; + boolean result = userShoppingcart.deleteProduct(productId); + if(!result) return false; + repository.save(userShoppingcart); + if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); + return true; + } } From 8a1e8ee8c5106426a8a856235dcc8813ed7dc393 Mon Sep 17 00:00:00 2001 From: Ray Date: Sun, 26 Nov 2023 22:19:06 +0800 Subject: [PATCH 073/163] feat: add ProductClassificatedBySeller class, which would show products classificated by seller when calling view function --- .../controller/ShoppingcartController.java | 8 +++---- .../entity/ProductClassificatedBySeller.java | 24 +++++++++++++++++++ 2 files changed, 28 insertions(+), 4 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 82e14d3..3cc0844 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -1,7 +1,7 @@ package ntou.auction.spring.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.ProductAddAmount; +import ntou.auction.spring.data.entity.ProductClassificatedBySeller; import ntou.auction.spring.data.entity.Shoppingcart; import ntou.auction.spring.data.entity.ShoppingcartRequest; import ntou.auction.spring.data.service.ProductService; @@ -42,13 +42,13 @@ public ShoppingcartController(ShoppingcartService shoppingcartService, ProductSe @GetMapping("/view") @ResponseBody - List getProduct() { + ProductClassificatedBySeller getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Shoppingcart userShoppingcart = shoppingcartService.getByUserId(userId); if(userShoppingcart==null) return null; - List result = new ArrayList<>(); + ProductClassificatedBySeller result = new ProductClassificatedBySeller(); for(Map.Entry product: userShoppingcart.getProductItems().entrySet()) { - result.add(new ProductAddAmount(productService.getID(product.getKey()), product.getValue())); + result.addProduct(productService.getID(product.getKey()), product.getValue()); } return result; } diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java b/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java new file mode 100644 index 0000000..9a36ad3 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java @@ -0,0 +1,24 @@ +package ntou.auction.spring.data.entity; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Getter +@NoArgsConstructor +@AllArgsConstructor +public class ProductClassificatedBySeller { + private Map> ProductShowBySeller = new HashMap<>(); + public void addProduct(Product product, Long amount) { + String seller = product.getSeller(); + if(!ProductShowBySeller.containsKey(seller)) ProductShowBySeller.put(seller, new ArrayList<>()); + List getProducts = ProductShowBySeller.get(seller); + getProducts.add(new ProductAddAmount(product, amount)); + ProductShowBySeller.replace(seller, getProducts); + } +} From 46d3a7887e5fbdfd9cdcb030f4faf3a9566473f0 Mon Sep 17 00:00:00 2001 From: Ray Date: Tue, 28 Nov 2023 23:16:48 +0800 Subject: [PATCH 074/163] fix: Fix an issue in the view controller related to the display of sellerNames. --- .../controller/ShoppingcartController.java | 33 +++++++++++++------ .../entity/ProductClassificatedBySeller.java | 10 ++---- .../data/entity/ShoppingcartRequest.java | 2 +- 3 files changed, 26 insertions(+), 19 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 3cc0844..e3b4a0f 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -1,9 +1,7 @@ package ntou.auction.spring.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.ProductClassificatedBySeller; -import ntou.auction.spring.data.entity.Shoppingcart; -import ntou.auction.spring.data.entity.ShoppingcartRequest; +import ntou.auction.spring.data.entity.*; import ntou.auction.spring.data.service.ProductService; import ntou.auction.spring.data.service.ShoppingcartService; import ntou.auction.spring.data.service.UserIdentity; @@ -12,10 +10,7 @@ import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Map; +import java.util.*; @RestController @RequestMapping(value = "/api/v1/shoppingcart", produces = MediaType.APPLICATION_JSON_VALUE) @@ -46,17 +41,35 @@ ProductClassificatedBySeller getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Shoppingcart userShoppingcart = shoppingcartService.getByUserId(userId); if(userShoppingcart==null) return null; - ProductClassificatedBySeller result = new ProductClassificatedBySeller(); + Map> result = new HashMap<>(); for(Map.Entry product: userShoppingcart.getProductItems().entrySet()) { - result.addProduct(productService.getID(product.getKey()), product.getValue()); + System.out.println(product.getKey() + " " + product.getValue()); + Product nowProduct = productService.getID(product.getKey()); + Long sellerId = nowProduct.getSellerID(); + Optional sellerUser = userService.get(sellerId); + if (sellerUser.isEmpty()) { + shoppingcartService.deleteProductByUserId(userId, product.getKey()); + continue; + } + String sellerName = sellerUser.get().getUsername(); + if (!result.containsKey("@" + sellerName)) { + result.put("@" + sellerName, new ArrayList<>()); + } + List getProducts = result.get("@" + sellerName); + if (getProducts == null) getProducts = new ArrayList<>(); + getProducts.add(new ProductAddAmount(nowProduct, product.getValue())); + result.replace(sellerName, getProducts); } - return result; + ProductClassificatedBySeller re = new ProductClassificatedBySeller(); + re.setProductShowBySeller(result); + return re; } @PostMapping("/add") ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); Long amount = request.getAmount(); + if(productService.getID(addProductId)==null) return ResponseEntity.badRequest().body(failMessage); shoppingcartService.addProductByUserId(userId, addProductId, amount==null?1L:amount); return ResponseEntity.ok(successMessage); } diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java b/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java index 9a36ad3..06bf779 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java +++ b/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java @@ -3,22 +3,16 @@ import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; +import lombok.Setter; -import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; @Getter +@Setter @NoArgsConstructor @AllArgsConstructor public class ProductClassificatedBySeller { private Map> ProductShowBySeller = new HashMap<>(); - public void addProduct(Product product, Long amount) { - String seller = product.getSeller(); - if(!ProductShowBySeller.containsKey(seller)) ProductShowBySeller.put(seller, new ArrayList<>()); - List getProducts = ProductShowBySeller.get(seller); - getProducts.add(new ProductAddAmount(product, amount)); - ProductShowBySeller.replace(seller, getProducts); - } } diff --git a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java index 130707d..ce6d3df 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java +++ b/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java @@ -11,6 +11,6 @@ public class ShoppingcartRequest { @NotNull private Long productId; - + @NotNull private Long amount; } From cb84d6faf61ff922d5a95b9abf7e21b8e422e0ff Mon Sep 17 00:00:00 2001 From: Ray Date: Tue, 28 Nov 2023 23:30:55 +0800 Subject: [PATCH 075/163] style: refine view style for improved clarity --- .../auction/spring/controller/ShoppingcartController.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index e3b4a0f..e7a3b1d 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -60,9 +60,7 @@ ProductClassificatedBySeller getProduct() { getProducts.add(new ProductAddAmount(nowProduct, product.getValue())); result.replace(sellerName, getProducts); } - ProductClassificatedBySeller re = new ProductClassificatedBySeller(); - re.setProductShowBySeller(result); - return re; + return new ProductClassificatedBySeller(result); } @PostMapping("/add") ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRequest request) { From b90a5dabf5fef4e1d6850fa764dbc280f032c5c8 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 14:25:40 +0800 Subject: [PATCH 076/163] Create codecov test --- .github/workflows/codecov.yaml | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 .github/workflows/codecov.yaml diff --git a/.github/workflows/codecov.yaml b/.github/workflows/codecov.yaml new file mode 100644 index 0000000..e420c7d --- /dev/null +++ b/.github/workflows/codecov.yaml @@ -0,0 +1,4 @@ +- name: Upload coverage reports to Codecov + uses: codecov/codecov-action@v3 + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} From 2db4aee719c0cf1b9c2f9d078e52b8183a9d5978 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 14:29:15 +0800 Subject: [PATCH 077/163] Rename codecov.yaml to codecov.yml --- .github/workflows/{codecov.yaml => codecov.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename .github/workflows/{codecov.yaml => codecov.yml} (100%) diff --git a/.github/workflows/codecov.yaml b/.github/workflows/codecov.yml similarity index 100% rename from .github/workflows/codecov.yaml rename to .github/workflows/codecov.yml From 06fd65f5cee3de9b88539a2056f09236895c7405 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 15:04:27 +0800 Subject: [PATCH 078/163] Update codecov.yml --- .github/workflows/codecov.yml | 34 ++++++++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 4 deletions(-) diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index e420c7d..dd75b25 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -1,4 +1,30 @@ -- name: Upload coverage reports to Codecov - uses: codecov/codecov-action@v3 - env: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} +name: Workflow for Codecov java maven +on: [push, pull_request] +env: + NA_DB_URL: 'jdbc:mariadb://localhost:3306/NA' + NA_DB_USER: 'NA' + NA_DB_PASSWORD: ${{ secrets.DBPassword }} +jobs: + run: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Set up JDK 21 + uses: actions/setup-java@v1 + with: + java-version: 21 + - name: Start MariaDB + uses: getong/mariadb-action@v1.1 + with: + mysql database: 'NA' + mysql user: 'NA' + mysql password: ${{ secrets.DBPassword }} + - name: Install dependencies + run: mvn install -DskipTests=true -Dmaven.javadoc.skip=true -B -V + - name: Run tests and collect coverage + run: mvn -B test + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v4-beta + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_ORG_TOKEN }} From 73e69788f205d8dbb789bb95457f63e8a52bf968 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 15:07:22 +0800 Subject: [PATCH 079/163] Update codecov.yml --- .github/workflows/codecov.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index dd75b25..406ddc8 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -16,8 +16,8 @@ jobs: java-version: 21 - name: Start MariaDB uses: getong/mariadb-action@v1.1 - with: - mysql database: 'NA' + with: + mysql database: 'NA' mysql user: 'NA' mysql password: ${{ secrets.DBPassword }} - name: Install dependencies From 7c831f9b8fb897c902ee0c1a2f60e6aa258a7468 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 15:13:38 +0800 Subject: [PATCH 080/163] Update codecov.yml --- .github/workflows/codecov.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index 406ddc8..016a184 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -27,4 +27,4 @@ jobs: - name: Upload coverage to Codecov uses: codecov/codecov-action@v4-beta env: - CODECOV_TOKEN: ${{ secrets.CODECOV_ORG_TOKEN }} + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} From 408d17905dc8b606f9034fac86ce3754fcaa25d1 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 15:44:45 +0800 Subject: [PATCH 081/163] Update codecov.yml --- .github/workflows/codecov.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index 016a184..64574d1 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -3,7 +3,7 @@ on: [push, pull_request] env: NA_DB_URL: 'jdbc:mariadb://localhost:3306/NA' NA_DB_USER: 'NA' - NA_DB_PASSWORD: ${{ secrets.DBPassword }} + NA_DB_PASSWORD: ${{ secrets.DBPASSWORD }} jobs: run: runs-on: ubuntu-latest @@ -19,7 +19,7 @@ jobs: with: mysql database: 'NA' mysql user: 'NA' - mysql password: ${{ secrets.DBPassword }} + mysql password: ${{ secrets.DBPASSWORD }} - name: Install dependencies run: mvn install -DskipTests=true -Dmaven.javadoc.skip=true -B -V - name: Run tests and collect coverage From a1455e75d188b720272cbca08af9abaf4a3f6fa7 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 15:57:09 +0800 Subject: [PATCH 082/163] Update codecov.yml --- .github/workflows/codecov.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index 64574d1..b2e7156 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -19,7 +19,7 @@ jobs: with: mysql database: 'NA' mysql user: 'NA' - mysql password: ${{ secrets.DBPASSWORD }} + mysql password: 'NA' - name: Install dependencies run: mvn install -DskipTests=true -Dmaven.javadoc.skip=true -B -V - name: Run tests and collect coverage From 9f847b54811939b619ea23ea14b41e760594f19f Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 16:03:29 +0800 Subject: [PATCH 083/163] Update codecov.yml --- .github/workflows/codecov.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index b2e7156..b7fc200 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -3,7 +3,7 @@ on: [push, pull_request] env: NA_DB_URL: 'jdbc:mariadb://localhost:3306/NA' NA_DB_USER: 'NA' - NA_DB_PASSWORD: ${{ secrets.DBPASSWORD }} + NA_DB_PASSWORD: 'NA' jobs: run: runs-on: ubuntu-latest From 2e6545c26f0d282427ee8483f7c94616214cd5c9 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 23:45:13 +0800 Subject: [PATCH 084/163] fix: Restrict WebSocket connections to only allow access with a valid JWT token. --- .../auction/spring/chat/config/AuthChannelInterceptor.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java index 82243f7..2084154 100644 --- a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java +++ b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java @@ -11,6 +11,7 @@ import org.springframework.messaging.simp.stomp.StompHeaderAccessor; import org.springframework.messaging.support.ChannelInterceptor; import org.springframework.messaging.support.MessageHeaderAccessor; +import org.springframework.security.access.AccessDeniedException; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.Authentication; import org.springframework.security.core.userdetails.UserDetails; @@ -49,8 +50,14 @@ public Message preSend(Message message, MessageChannel channel) { new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword()); accessor.setUser(authentication); return message; + }else{ + System.out.println("WebSocket連線驗證失敗"); + throw new AccessDeniedException("WebSocket連線驗證失敗"); } } + }else{ + System.out.println("WebSocket連線驗證失敗"); + throw new AccessDeniedException("WebSocket連線驗證失敗"); } } System.out.println("message:" + message); From 4286bdf4ea85757df0b3b3238ebfe29c2ac8a2d2 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Thu, 30 Nov 2023 20:15:26 +0800 Subject: [PATCH 085/163] =?UTF-8?q?feat:=20Ability=20to=20add=20products?= =?UTF-8?q?=20to=20the=20shopping=20cart=20with=20quantity=20validation.(J?= =?UTF-8?q?ust=20for=20=E4=B8=8D=E4=BA=8C=E5=83=B9)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 23 ++++++++++++++++++- .../spring/data/entity/BuyProductRequest.java | 22 ++++++++++++++++++ 2 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 src/main/java/ntou/auction/spring/data/entity/BuyProductRequest.java diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index d2eae35..5a3c367 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -3,6 +3,7 @@ import jakarta.validation.Valid; import ntou.auction.spring.data.entity.*; import ntou.auction.spring.data.service.ProductService; +import ntou.auction.spring.data.service.ShoppingcartService; import ntou.auction.spring.data.service.UserIdentity; import ntou.auction.spring.data.service.UserService; import org.springframework.http.MediaType; @@ -23,12 +24,14 @@ public class ProductController { private final ProductService productService; private final UserIdentity userIdentity; private final UserService userService; + private final ShoppingcartService shoppingcartService; - public ProductController(ProductService productService,UserIdentity userIdentity,UserService userService) { + public ProductController(ProductService productService, UserIdentity userIdentity, UserService userService, ShoppingcartService shoppingcartService) { this.productService = productService; this.userIdentity = userIdentity; this.userService = userService; + this.shoppingcartService = shoppingcartService; } @@ -146,4 +149,22 @@ ResponseEntity> bidProduct(@Valid @RequestBody BidRequest req return ResponseEntity.ok(successMessage); } + @PostMapping("/buy") + ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequest request){ + + Map successMessage = Collections.singletonMap("message","成功加入購物車"); + Map notEnoughMessage = Collections.singletonMap("message","買太多嚕"); + Map errorMessage = Collections.singletonMap("message","你只能將不二價商品加入購物車"); + + if(request.getProductAmount() > productService.getID(request.getProductID()).getProductAmount()) { //要買的數量 > 商品剩餘數量 + return ResponseEntity.badRequest().body(notEnoughMessage); + } + if(!productService.getID(request.getProductID()).getIsFixedPrice()){ + return ResponseEntity.badRequest().body(errorMessage); + } + //public void addProductByUserId(Long userId, Long productId, Long amount) { + shoppingcartService.addProductByUserId(userService.findByUsername(userIdentity.getUsername()).getId(), request.getProductID(), request.getProductAmount()); + return ResponseEntity.ok(successMessage); + } + } diff --git a/src/main/java/ntou/auction/spring/data/entity/BuyProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/BuyProductRequest.java new file mode 100644 index 0000000..31e1a9e --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/BuyProductRequest.java @@ -0,0 +1,22 @@ +package ntou.auction.spring.data.entity; + +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class BuyProductRequest { + + @NotNull (message="商品ID不得為空") + private Long productID; + + @NotNull (message="商品數量不得為空") + @Min (value = 1,message = "商品至少一個") + private Long productAmount; + +} From 8c07a897e9435027cca3eca115c40f9212daa8e1 Mon Sep 17 00:00:00 2001 From: Ray Date: Thu, 30 Nov 2023 23:05:22 +0800 Subject: [PATCH 086/163] Fix: Ensure product amount doesn't exceed the limit and include distinct HTML bodies for bad request scenarios. --- .../controller/ShoppingcartController.java | 22 ++++++++++++----- .../spring/data/entity/Shoppingcart.java | 10 ++++---- .../data/service/ShoppingcartService.java | 24 ++++++++++++------- 3 files changed, 36 insertions(+), 20 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index e7a3b1d..084d561 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -21,6 +21,12 @@ public class ShoppingcartController { private static final Map successMessage = Collections.singletonMap("message","成功"); private static final Map failMessage = Collections.singletonMap("message","好像發生了什麼錯誤，請檢查一下腦袋"); + private static final Map ErrorIdMessage = Collections.singletonMap("message","沒這商品，跟你女友一樣不存在"); + + private static final Map ErrorAmountZeroMessage = Collections.singletonMap("message","你知道這商品的數量會變得跟你腦袋一樣是負的嗎"); + + private static final Map ErrorAmountExceedMessage = Collections.singletonMap("message","商品滿書來了"); + private final UserService userService; private final UserIdentity userIdentity; @@ -67,9 +73,9 @@ ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRe Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); Long amount = request.getAmount(); - if(productService.getID(addProductId)==null) return ResponseEntity.badRequest().body(failMessage); - shoppingcartService.addProductByUserId(userId, addProductId, amount==null?1L:amount); - return ResponseEntity.ok(successMessage); + if(productService.getID(addProductId)==null) return ResponseEntity.badRequest().body(ErrorIdMessage); + boolean result = shoppingcartService.addProductByUserId(userId, addProductId, amount==null?1L:amount); + return result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(ErrorAmountExceedMessage); } @DeleteMapping("/decrease") @@ -77,16 +83,20 @@ ResponseEntity> decreaseProduct(@Valid @RequestBody Shoppingc Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); Long amount = request.getAmount(); - boolean result = shoppingcartService.decreaseProductByUserId(userId, addProductId, amount==null?1L:amount); - return (result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(failMessage)); + Long result = shoppingcartService.decreaseProductByUserId(userId, addProductId, amount==null?1L:amount); + // 0: exist error, 1: amount error, 2: OK + if(result.equals(0L)) return ResponseEntity.badRequest().body(ErrorIdMessage); //shoppingcart does not exist + if(result.equals(1L)) return ResponseEntity.badRequest().body(ErrorAmountZeroMessage); //amount error + return ResponseEntity.ok(successMessage); } + @DeleteMapping("/delete") ResponseEntity> deleteProduct(@Valid @RequestBody ShoppingcartRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); boolean result = shoppingcartService.deleteProductByUserId(userId, addProductId); - return (result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(failMessage)); + return (result?ResponseEntity.ok(successMessage):ResponseEntity.badRequest().body(ErrorIdMessage)); } @DeleteMapping("/deleteall") diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java index cb0f8a4..2bbdc59 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -31,16 +31,16 @@ public void addProductId(Long product, Long amount) { productItems.replace(product, productItems.get(product)+amount); } - public boolean decreaseProduct(Long product, Long amount) { - if (productItems.get(product) == null) return false; + public Long decreaseProduct(Long product, Long amount) { + if (productItems.get(product) == null) return 0L; if (productItems.get(product) == 0L) { productItems.remove(product); - return false; + return 0L; } - if(productItems.get(product) < amount) return false; + if(productItems.get(product) < amount) return 1L; productItems.replace(product, productItems.get(product) - amount); if (productItems.get(product) == 0L) productItems.remove(product); - return true; + return 2L; } public boolean deleteProduct(Long product) { diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java index eada01d..c3d9e3c 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -4,7 +4,6 @@ import ntou.auction.spring.data.entity.Shoppingcart; import org.springframework.stereotype.Service; -import java.lang.reflect.Array; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -13,9 +12,11 @@ @Service public class ShoppingcartService { private final ShoppingcartRepository repository; + private final ProductService productService; - public ShoppingcartService(ShoppingcartRepository repository) { + public ShoppingcartService(ShoppingcartRepository repository, ProductService productService) { this.repository = repository; + this.productService = productService; } public Shoppingcart getByUserId(Long userId) { @@ -41,7 +42,7 @@ public boolean deleteShoppingcartByUserId(Long userId) { return true; } - public void addProductByUserId(Long userId, Long productId, Long amount) { + public boolean addProductByUserId(Long userId, Long productId, Long amount) { Shoppingcart userShoppingcart = getByUserId(userId); if (userShoppingcart == null) { Map product = new HashMap<>(); @@ -49,25 +50,30 @@ public void addProductByUserId(Long userId, Long productId, Long amount) { repository.save(newShoppingcart); userShoppingcart = getByUserId(userId); } + Product product = productService.getID(productId); + if (product == null) return false; //already been checked + Long alreadyAmount = userShoppingcart.getProductItems().get(productId) == null ? 0L : userShoppingcart.getProductItems().get(productId); + if (alreadyAmount + amount > product.getProductAmount()) return false; userShoppingcart.addProductId(productId, amount); repository.save(userShoppingcart); + return true; } - public boolean decreaseProductByUserId(Long userId, Long productId, Long amount) { + public Long decreaseProductByUserId(Long userId, Long productId, Long amount) { Shoppingcart userShoppingcart = getByUserId(userId); - if (userShoppingcart == null) return false; - boolean result = userShoppingcart.decreaseProduct(productId, amount); - if (!result) return false; + if (userShoppingcart == null) return 0L; + Long result = userShoppingcart.decreaseProduct(productId, amount); + if (!result.equals(2L)) return result; repository.save(userShoppingcart); if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); - return true; + return 2L; } public boolean deleteProductByUserId(Long userId, Long productId) { Shoppingcart userShoppingcart = getByUserId(userId); if (userShoppingcart == null) return false; boolean result = userShoppingcart.deleteProduct(productId); - if(!result) return false; + if (!result) return false; repository.save(userShoppingcart); if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); return true; From ead16647f9c1c559901b912607af421032d108d7 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 1 Dec 2023 16:14:54 +0800 Subject: [PATCH 087/163] =?UTF-8?q?fix:=20=E8=B3=BC=E7=89=A9=E8=BB=8A?= =?UTF-8?q?=E5=85=A7=E5=8E=9F=E6=9C=89=E7=9A=84=E5=95=86=E5=93=81=E6=95=B8?= =?UTF-8?q?=E9=87=8F=E4=B8=80=E4=BD=B5=E7=B4=8D=E5=85=A5=E6=AA=A2=E6=9F=A5?= =?UTF-8?q?=E7=AF=84=E5=9C=8D=EF=BC=8C=E6=AA=A2=E6=9F=A5=E5=95=86=E5=93=81?= =?UTF-8?q?=E6=98=AF=E5=90=A6=E5=AD=98=E5=9C=A8=20feat:=20=E5=8F=AF?= =?UTF-8?q?=E4=BB=A5=E9=A1=AF=E7=A4=BA=E8=B3=A3=E5=AE=B6=E4=B8=8A=E6=9E=B6?= =?UTF-8?q?=E7=9A=84=E5=95=86=E5=93=81(=E5=89=8D=E7=AB=AF=E6=89=80?= =?UTF-8?q?=E9=9C=80=E8=B3=A3=E5=AE=B6=E4=B8=AD=E5=BF=83=E5=8A=9F=E8=83=BD?= =?UTF-8?q?)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 37 ++++++++++++++++++- .../data/service/ProductRepository.java | 2 +- .../spring/data/service/ProductService.java | 2 + 3 files changed, 39 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 5a3c367..ab82fef 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -155,8 +155,37 @@ ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequ Map successMessage = Collections.singletonMap("message","成功加入購物車"); Map notEnoughMessage = Collections.singletonMap("message","買太多嚕"); Map errorMessage = Collections.singletonMap("message","你只能將不二價商品加入購物車"); + Map productNotExistMessage = Collections.singletonMap("message", "商品不存在或無法購買"); - if(request.getProductAmount() > productService.getID(request.getProductID()).getProductAmount()) { //要買的數量 > 商品剩餘數量 + // 商品是否存在 + if( productService.getID(request.getProductID())==null){ + return ResponseEntity.badRequest().body(productNotExistMessage); + } + + // 購物車是空的 + // 只檢查request送來的加入數量 + if (shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId())==null){ + if (request.getProductAmount() > productService.getID(request.getProductID()).getProductAmount()) { + return ResponseEntity.badRequest().body(notEnoughMessage); + } else { + shoppingcartService.addProductByUserId(userService.findByUsername(userIdentity.getUsername()).getId(), request.getProductID(), request.getProductAmount()); + return ResponseEntity.ok(successMessage); + } + } + // 購物車裡面還沒有要加入的商品 + // 只檢查request送來的加入數量 + if(shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId()).getProductItems().get(request.getProductID())==null){ + if (request.getProductAmount() > productService.getID(request.getProductID()).getProductAmount()) { + return ResponseEntity.badRequest().body(notEnoughMessage); + } else { + shoppingcartService.addProductByUserId(userService.findByUsername(userIdentity.getUsername()).getId(), request.getProductID(), request.getProductAmount()); + return ResponseEntity.ok(successMessage); + } + } + + // 購物車裡面已經有要加入的商品 + // 檢查request送來的加入數量加上原先購物車內的商品數量 + if (request.getProductAmount() + shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId()).getProductItems().get(request.getProductID()) > productService.getID(request.getProductID()).getProductAmount()) { //要買的數量 > 商品剩餘數量 return ResponseEntity.badRequest().body(notEnoughMessage); } if(!productService.getID(request.getProductID()).getIsFixedPrice()){ @@ -167,4 +196,10 @@ ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequ return ResponseEntity.ok(successMessage); } + @GetMapping("/sellercenter") + @ResponseBody + List getProductInSellerCenter() { + return productService.findBySellerID(userService.findByUsername(userIdentity.getUsername()).getId()); + } + } diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index 15cc95f..80d1929 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -24,7 +24,7 @@ public interface ProductRepository extends JpaRepository, List findAllByFuzzyProductName(@Param("productName") String productName); // ?1:productName - + List findBySellerID(long ID); List findAllByProductType(String productType); diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index e18b508..67155f9 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -80,4 +80,6 @@ public List findByProductClassification(String productType){ public List findByProductNonFixed(){ return repository.findAllByIsFixedPriceFalse(); } + + public List findBySellerID(Long sellerID){return repository.findBySellerID(sellerID);}//賣家中心 } From 36fb21063f8592086793d0fca4e5af47650f6a60 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 1 Dec 2023 16:22:59 +0800 Subject: [PATCH 088/163] =?UTF-8?q?fix:=20userID=20=E8=AE=8A=E6=AD=A3?= =?UTF-8?q?=E5=B8=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/resources/data.sql | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 8f755b0..7000ac9 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -18,7 +18,7 @@ insert into user_roles (user_id, roles) values (1, 'ADMIN'); insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,1,'IPhone13','electronic',true,'ggggg',1057088,null,3,1500,"2023-11-04 19:45:00",null,null,null); +values (1,1,'IPhone13','electronic',true,'ggggg',1,null,3,1500,"2023-11-04 19:45:00",null,null,null); @@ -28,7 +28,7 @@ values (1,2,'IPhone18','electronic',true,'ggggg',1057088,null,3,1500,"2023-11-04 */ insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,3,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); +values (1,3,'IPhone13','electronic',false,'ggggg',1,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,4,'IPhone13','electronic',false,'ggggg',1057088,1000,1,1500,"2023-11-04 19:45:00","2023-11-30 18:45:00",1000,null); +values (1,4,'IPhone13','electronic',false,'ggggg',1,1000,1,1500,"2023-11-04 19:45:00","2023-11-30 18:45:00",1000,null); From 7c23aa70beb1f546560e539cae15547b7fd2307b Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 2 Dec 2023 23:42:11 +0800 Subject: [PATCH 089/163] =?UTF-8?q?feat:=20=E5=B0=87=E7=AB=B6=E6=A8=99?= =?UTF-8?q?=E7=B5=90=E6=9D=9F=E7=9A=84=E5=95=86=E5=93=81=E5=8A=A0=E5=85=A5?= =?UTF-8?q?=E5=BE=97=E6=A8=99=E8=80=85=E8=B3=BC=E7=89=A9=E8=BB=8A=EF=BC=8C?= =?UTF-8?q?=E9=81=BF=E5=85=8D=E9=87=8D=E8=A4=87=E5=8A=A0=E5=85=A5=E8=B3=BC?= =?UTF-8?q?=E7=89=A9=E8=BB=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 2 ++ .../auction/spring/data/entity/Product.java | 2 ++ .../data/service/ProductRepository.java | 2 +- .../spring/data/service/ProductService.java | 2 +- .../spring/data/service/TimerTask.java | 26 ++++++++++++++++--- 5 files changed, 29 insertions(+), 5 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index ab82fef..3565d9d 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -84,6 +84,7 @@ ResponseEntity> postProduct(@Valid @RequestBody PostFixedPric product.setUpsetPrice(null); product.setBidIncrement(null); product.setProductAmount(request.getProductAmount()); + product.setIsAuction(false); product.setSellerID(userService.findByUsername(userIdentity.getUsername()).getId()); product.setUpdateTime(LocalDateTime.now()); @@ -110,6 +111,7 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedP product.setUpsetPrice(request.getUpsetPrice()); product.setBidIncrement(request.getBidIncrement()); product.setProductAmount(1L); + product.setIsAuction(false); LocalDateTime now = LocalDateTime.now(); diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index b70f698..78cf67d 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -53,6 +53,8 @@ public class Product extends AbstractEntity { private Long bidIncrement; + private Boolean isAuction; //競標商品已經被加進購物車? + @NotNull @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") private LocalDateTime updateTime; diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index 80d1929..784419b 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -15,7 +15,7 @@ public interface ProductRepository extends JpaRepository, Product findByProductName(String productName); - List findAllByIsFixedPriceFalse(); + List findAllByIsFixedPriceFalseAndIsAuctionFalse(); Product findById(long id); diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index 67155f9..531cc93 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -78,7 +78,7 @@ public List findByProductClassification(String productType){ } public List findByProductNonFixed(){ - return repository.findAllByIsFixedPriceFalse(); + return repository.findAllByIsFixedPriceFalseAndIsAuctionFalse(); } public List findBySellerID(Long sellerID){return repository.findBySellerID(sellerID);}//賣家中心 diff --git a/src/main/java/ntou/auction/spring/data/service/TimerTask.java b/src/main/java/ntou/auction/spring/data/service/TimerTask.java index 6a02a02..2a7fac3 100644 --- a/src/main/java/ntou/auction/spring/data/service/TimerTask.java +++ b/src/main/java/ntou/auction/spring/data/service/TimerTask.java @@ -3,24 +3,44 @@ import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import ntou.auction.spring.data.entity.Product; +import org.springframework.transaction.annotation.Transactional; import java.util.List; +import java.util.Map; +import java.util.Optional; @Component public class TimerTask { private final ProductService productService; + private final ShoppingcartService shoppingcartService; - public TimerTask(ProductService productService) { + public TimerTask(ProductService productService, ShoppingcartService shoppingcartService, UserIdentity userIdentity, UserService userService) { this.productService = productService; + this.shoppingcartService = shoppingcartService; } - + @Transactional @Scheduled(cron = "0 * * * * ?") //每分鐘的第0秒 public void execute() { List productList = productService.findByProductNonFixed(); for (Product product : productList) { + System.out.println(product.getId()); if (product.isExpired()) { - System.out.println("這個id = "+product.getId() + "的商品競標結束了"); + Map productMap= product.getBidInfo(); + + + Optional> max0 = productMap.entrySet() + .stream().max(Map.Entry.comparingByValue()); + if(max0.isPresent()) { + shoppingcartService.addProductByUserId(max0.get().getKey(),product.getId(),1L); + product.setIsAuction(true); + productService.store(product); + } + else { + product.setIsAuction(true); + productService.store(product); + } + } } } From 74abad88c588f3098ffe259c976fbec419396426 Mon Sep 17 00:00:00 2001 From: Ray Date: Sun, 3 Dec 2023 20:43:07 +0800 Subject: [PATCH 090/163] Fix: change the HTML body --- .../auction/spring/controller/ShoppingcartController.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 084d561..8525c2e 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -19,13 +19,13 @@ public class ShoppingcartController { private final ShoppingcartService shoppingcartService; private final ProductService productService; private static final Map successMessage = Collections.singletonMap("message","成功"); - private static final Map failMessage = Collections.singletonMap("message","好像發生了什麼錯誤，請檢查一下腦袋"); + private static final Map failMessage = Collections.singletonMap("message","操作失敗"); - private static final Map ErrorIdMessage = Collections.singletonMap("message","沒這商品，跟你女友一樣不存在"); + private static final Map ErrorIdMessage = Collections.singletonMap("message","商品不存在"); - private static final Map ErrorAmountZeroMessage = Collections.singletonMap("message","你知道這商品的數量會變得跟你腦袋一樣是負的嗎"); + private static final Map ErrorAmountZeroMessage = Collections.singletonMap("message","商品數量不可變為負的"); - private static final Map ErrorAmountExceedMessage = Collections.singletonMap("message","商品滿書來了"); + private static final Map ErrorAmountExceedMessage = Collections.singletonMap("message","商品數量過多"); private final UserService userService; From 82a78c310a9627618e88fe35e2d7a5b210d7c170 Mon Sep 17 00:00:00 2001 From: Ray Date: Sun, 3 Dec 2023 20:47:32 +0800 Subject: [PATCH 091/163] Style: change the url of getProduct --- .../spring/controller/ShoppingcartController.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 8525c2e..37a04f0 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -37,11 +37,12 @@ public ShoppingcartController(ShoppingcartService shoppingcartService, ProductSe this.userService = userService; this.userIdentity = userIdentity; } - @GetMapping("/shoppingcart") + /* + @GetMapping("/view") @ResponseBody List getShoppingcartProfile() { return shoppingcartService.list(); } - - @GetMapping("/view") + */ + @GetMapping("/shoppingcart") @ResponseBody ProductClassificatedBySeller getProduct() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); @@ -68,7 +69,7 @@ ProductClassificatedBySeller getProduct() { } return new ProductClassificatedBySeller(result); } - @PostMapping("/add") + @PostMapping("/increase") ResponseEntity> addProduct(@Valid @RequestBody ShoppingcartRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); Long addProductId = request.getProductId(); From fc93b779fe13450313859797bae29c2057485251 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Thu, 7 Dec 2023 00:13:48 +0800 Subject: [PATCH 092/163] =?UTF-8?q?fix:=20=E6=96=B0=E5=A2=9E=E5=B1=AC?= =?UTF-8?q?=E6=80=A7sellerName?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/ntou/auction/spring/controller/ProductController.java | 2 ++ src/main/java/ntou/auction/spring/data/entity/Product.java | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 3565d9d..39d1d49 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -86,6 +86,7 @@ ResponseEntity> postProduct(@Valid @RequestBody PostFixedPric product.setProductAmount(request.getProductAmount()); product.setIsAuction(false); product.setSellerID(userService.findByUsername(userIdentity.getUsername()).getId()); + product.setSellerName(userIdentity.getUsername()); product.setUpdateTime(LocalDateTime.now()); @@ -116,6 +117,7 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedP LocalDateTime now = LocalDateTime.now(); product.setSellerID(userService.findByUsername(userIdentity.getUsername()).getId()); + product.setSellerName(userIdentity.getUsername()); product.setUpdateTime(now); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index 78cf67d..1742e15 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -38,6 +38,8 @@ public class Product extends AbstractEntity { @NotNull private Long sellerID; + private String sellerName; + private Long productAmount; //followings are non-isFixedPrice feature From 1d57c87e42256ad50667236bd4c6b8588876eafd Mon Sep 17 00:00:00 2001 From: weichunnien Date: Thu, 7 Dec 2023 00:57:44 +0800 Subject: [PATCH 093/163] =?UTF-8?q?feat:=20=E6=96=B0=E5=A2=9Efunction=20?= =?UTF-8?q?=E5=95=86=E5=93=81=E6=95=B8=E9=87=8F=E6=B8=9B=E5=B0=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ntou/auction/spring/data/service/ProductService.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index 531cc93..8a2a3d7 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -68,6 +68,12 @@ public void bid(Long bid,Long id,Long userID){ } } + public void productAmountDecrease(Long id,Long decrement){ + Product product = this.getID(id); + Long productAmount = product.getProductAmount(); + product.setProductAmount(productAmount - decrement); + this.store(product); + } public List findByProductName(String productName) { return repository.findAllByFuzzyProductName(productName); From 7fad8a83265392d21c7640e5bd657cc63c7dd7f1 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Thu, 7 Dec 2023 22:02:32 +0800 Subject: [PATCH 094/163] =?UTF-8?q?feat:=20=E6=96=B0=E5=A2=9Eservice=20?= =?UTF-8?q?=E5=95=86=E5=93=81=E6=95=B8=E9=87=8F=E5=A2=9E=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ntou/auction/spring/data/service/ProductService.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index 8a2a3d7..107b7f4 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -74,6 +74,12 @@ public void productAmountDecrease(Long id,Long decrement){ product.setProductAmount(productAmount - decrement); this.store(product); } + public void productAmountIncrease(Long id,Long increment){ + Product product = this.getID(id); + Long productAmount = product.getProductAmount(); + product.setProductAmount(productAmount + increment); + this.store(product); + } public List findByProductName(String productName) { return repository.findAllByFuzzyProductName(productName); From a78caa0a7eb926d6c203d569d70804d3bb5a043e Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 8 Dec 2023 17:04:19 +0800 Subject: [PATCH 095/163] Style: change statement of HTHL error body --- .../ntou/auction/spring/controller/ShoppingcartController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java index 37a04f0..72a9d35 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java @@ -25,7 +25,7 @@ public class ShoppingcartController { private static final Map ErrorAmountZeroMessage = Collections.singletonMap("message","商品數量不可變為負的"); - private static final Map ErrorAmountExceedMessage = Collections.singletonMap("message","商品數量過多"); + private static final Map ErrorAmountExceedMessage = Collections.singletonMap("message","加入的商品數量過多"); private final UserService userService; From 136b7b25a5de492fd0a2ec23ab5bacb9afc10d19 Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 8 Dec 2023 17:06:58 +0800 Subject: [PATCH 096/163] feat: Implement product quantity check to ensure availability --- .../spring/data/entity/Shoppingcart.java | 6 ++++++ .../data/service/ShoppingcartService.java | 17 +++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java index 2bbdc59..6b61d0d 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java +++ b/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java @@ -52,4 +52,10 @@ public boolean deleteProduct(Long product) { productItems.remove(product); return true; } + + public boolean checkIsEnoughAmountInProductItems(Long product, Long amount) { + if(amount.equals(0L)) return true; // this may not be happened + if(!productItems.containsKey(product)) return false; + return productItems.get(product) >= amount; + } } diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java index c3d9e3c..665792e 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -78,4 +78,21 @@ public boolean deleteProductByUserId(Long userId, Long productId) { if (userShoppingcart.getProductItems().isEmpty()) repository.deleteByUserid(userId); return true; } + + public boolean checkIsEnoughAmount(Long userId, Long productId, Long amount) { + Shoppingcart userShoppingcart = getByUserId(userId); + if (userShoppingcart == null) return false; + return userShoppingcart.checkIsEnoughAmountInProductItems(productId, amount); + } + + public Long checkIsProductAllInShoppingCart(List> order, Long userid) { + // -1: format error, 0: false, 1: true + for(List product: order) { + if(product.size()!=2) return -1L; + if(!checkIsEnoughAmount(userid, product.get(0), product.get(1))) { + return 0L; + } + } + return 1L; + } } From c1ebb5e7ab0691e6ab53f30fb1fca274c3926aee Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 8 Dec 2023 17:08:26 +0800 Subject: [PATCH 097/163] feat: Introduce order system functionality. --- .../auction/spring/data/entity/Order.java | 37 +++++ .../spring/data/service/OrderRepository.java | 36 +++++ .../spring/data/service/OrderService.java | 148 ++++++++++++++++++ 3 files changed, 221 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/data/entity/Order.java create mode 100644 src/main/java/ntou/auction/spring/data/service/OrderRepository.java create mode 100644 src/main/java/ntou/auction/spring/data/service/OrderService.java diff --git a/src/main/java/ntou/auction/spring/data/entity/Order.java b/src/main/java/ntou/auction/spring/data/entity/Order.java new file mode 100644 index 0000000..b293623 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/Order.java @@ -0,0 +1,37 @@ +package ntou.auction.spring.data.entity; + +import ch.qos.logback.core.joran.sanity.Pair; +import com.fasterxml.jackson.annotation.JsonFormat; +import jakarta.persistence.*; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.LocalDateTime; +import java.util.*; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +@Table(name = "orders") +public class Order extends AbstractEntity { + @NotNull + private Long buyerid; + + @NotNull + private Long sellerid; + + private List> productAddAmountList = new ArrayList<>(); + + @NotNull + private Long status; // 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private LocalDateTime updateTime; + + public void addProductAddAmount(List product) { + productAddAmountList.add(product); + } +} diff --git a/src/main/java/ntou/auction/spring/data/service/OrderRepository.java b/src/main/java/ntou/auction/spring/data/service/OrderRepository.java new file mode 100644 index 0000000..83a8496 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/OrderRepository.java @@ -0,0 +1,36 @@ +package ntou.auction.spring.data.service; + +import jakarta.transaction.Transactional; +import ntou.auction.spring.data.entity.Order; +import ntou.auction.spring.data.entity.Shoppingcart; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Modifying; +import org.springframework.data.jpa.repository.Query; + +import java.util.List; +import java.util.Optional; + +public interface OrderRepository extends JpaRepository, JpaSpecificationExecutor { + Optional findById(Long id); + @Query(value = "select * from orders o where o.buyerid = ?1", nativeQuery = true) + List findAllByBuyerid(Long buyer); + + @Query(value = "select * from orders o where o.buyerid = ?1 and o.status = 0", nativeQuery = true) + List findRejectByBuyerid(Long buyer); + + @Query(value = "select * from orders o where o.buyerid = ?1 and o.status = 1", nativeQuery = true) + List findWaitingByBuyerid(Long buyer); + + @Query(value = "select * from orders o where o.buyerid = ?1 and o.status = 2", nativeQuery = true) + List findSubmittedByBuyerid(Long buyer); + + @Query(value = "select * from orders o where o.buyerid = ?1 and o.status = 3", nativeQuery = true) + List findDoneByBuyerid(Long buyer); + + @Query(value = "select * from orders o where o.sellerid = ?1 and o.status = 1", nativeQuery = true) + List findWaitingBySellerid(Long seller); + @Modifying + @Query(value = "insert into shoppingcart(userId, productId) values (?1, ?2)", nativeQuery = true) + public void addShoppingCart(Long userId, List productId); +} diff --git a/src/main/java/ntou/auction/spring/data/service/OrderService.java b/src/main/java/ntou/auction/spring/data/service/OrderService.java new file mode 100644 index 0000000..d8101c5 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/service/OrderService.java @@ -0,0 +1,148 @@ +package ntou.auction.spring.data.service; + +import ntou.auction.spring.data.entity.Order; +import ntou.auction.spring.data.entity.OrderWithProductDetail; +import ntou.auction.spring.data.entity.ProductAddAmount; +import org.springframework.stereotype.Service; + +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; + +@Service +public class OrderService { + private final OrderRepository repository; + + private final ProductService productService; + + private final ShoppingcartService shoppingcartService; + + private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + public OrderService(OrderRepository repository, ProductService productService, ShoppingcartService shoppingcartService) { + this.repository = repository; + this.productService = productService; + this.shoppingcartService = shoppingcartService; + } + public Order findOrderById(Long Id) { + return repository.findById(Id).orElse(null); + } + public List findAllByBuyerId(Long buyerId) { + return repository.findAllByBuyerid(buyerId); + } + + public List findRejectByBuyerId(Long buyerId) { + return repository.findRejectByBuyerid(buyerId); + } + + public List findWaitingByBuyerId(Long buyerId) { + return repository.findWaitingByBuyerid(buyerId); + } + + public List findSubmittedByBuyerId(Long buyerId) { + return repository.findSubmittedByBuyerid(buyerId); + } + + public List findDoneByBuyerId(Long buyerId) { + return repository.findDoneByBuyerid(buyerId); + } + + public List findWaitingBySellerId(Long sellerId) { + return repository.findWaitingBySellerid(sellerId); + } + + public Long submitOrder(Long orderId, Long userId) { + // for status -> 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done + // for return -> 0: orderNotFound, 1: statusError, 2: idError, 3: success, -1: expired + Order getorder = repository.findById(orderId).orElse(null); + if(getorder == null) return 0L; + if(!getorder.getStatus().equals(1L)) return 1L; + if(!Objects.equals(findOrderById(orderId).getSellerid(), userId)) return 2L; + getorder.setStatus(2L); + repository.save(getorder); + return 3L; + } + + public Long rejectOrder(Long orderId, Long userId) { + // 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done + // for return -> 0: orderNotFound, 1: statusError, 2: idError, 3: success, -1: expired + Order getorder = repository.findById(orderId).orElse(null); + if(getorder == null) return 0L; + if(!getorder.getStatus().equals(1L)) return 1L; + if(!Objects.equals(findOrderById(orderId).getSellerid(), userId)) return 2L; + getorder.setStatus(0L); + repository.save(getorder); + return 3L; + } + + public Long cancelOrder(Long orderId, Long userId) { + // 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done + // for return -> 0: orderNotFound, 1: statusError, 2: idError, 3: success, -1: expired + Order getorder = repository.findById(orderId).orElse(null); + if(getorder == null) return 0L; + if(getorder.getStatus().equals(3L) || getorder.getStatus().equals(0L)) return 1L; + if(!Objects.equals(findOrderById(orderId).getBuyerid(), userId)) return 2L; + if(Duration.between(getorder.getUpdateTime(), LocalDateTime.parse(LocalDateTime.now().format(formatter), formatter)).toSeconds()>(86400*7L)) return -1L; + getorder.setStatus(0L); + repository.save(getorder); + return 3L; + } + // make order be done + public Long doneOrder(Long orderId, Long userId) { + // 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done + // for return -> 0: orderNotFound, 1: statusError, 2: idError, 3: success, -1: expired + Order getorder = repository.findById(orderId).orElse(null); + if(getorder == null) return 0L; + if(!getorder.getStatus().equals(2L)) return 1L; + if(!Objects.equals(findOrderById(orderId).getSellerid(), userId)) return 2L; + getorder.setStatus(3L); + repository.save(getorder); + return 3L; + } + + public boolean addOrder(Order order) { + boolean check = checkIsSameSeller(order.getProductAddAmountList()); + if(!check) return false; + repository.save(order); + return true; + } + + private boolean checkIsSameSeller(List> list) { + Set check = new HashSet<>(); + for(List productAddAmount: list) { + check.add(productService.getID(productAddAmount.get(0)).getSellerID()); + } + return check.size()==1; + } + + public List orderToOrderWithProductDetail(List getOrder) { + List result = new ArrayList<>(); + for(Order order: getOrder) { + OrderWithProductDetail addOrder = new OrderWithProductDetail(); + addOrder.setSellerid(order.getSellerid()); + addOrder.setBuyerid(order.getBuyerid()); + addOrder.setUpdateTime(order.getUpdateTime()); + addOrder.setStatus(order.getStatus()); + addOrder.setOrderid(order.getId()); + List temp = new ArrayList<>(); + for (List product : order.getProductAddAmountList()) { + temp.add(new ProductAddAmount(productService.getID(product.get(0)), product.get(1))); + } + addOrder.setProductAddAmountList(temp); + result.add(addOrder); + } + return result; + } + + public boolean addAmountToProduct(Order order) { + // (order == null) this may not be happened + if(order==null) return false; + // add product amount with amount + for(List eachProduct: order.getProductAddAmountList()) { + productService.productAmountIncrease(eachProduct.get(0), eachProduct.get(1)); + } + return true; + } + +} From 0f50d28bdead5e2861086ed62ca2155d19d3b3d1 Mon Sep 17 00:00:00 2001 From: Ray Date: Fri, 8 Dec 2023 17:09:25 +0800 Subject: [PATCH 098/163] feat: Implement order controller for managing and processing orders. --- .../spring/controller/OrderController.java | 186 ++++++++++++++++++ .../spring/data/entity/AddOrderRequest.java | 18 ++ .../data/entity/OperateOrderRequest.java | 14 ++ .../data/entity/OrderWithProductDetail.java | 35 ++++ 4 files changed, 253 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/controller/OrderController.java create mode 100644 src/main/java/ntou/auction/spring/data/entity/AddOrderRequest.java create mode 100644 src/main/java/ntou/auction/spring/data/entity/OperateOrderRequest.java create mode 100644 src/main/java/ntou/auction/spring/data/entity/OrderWithProductDetail.java diff --git a/src/main/java/ntou/auction/spring/controller/OrderController.java b/src/main/java/ntou/auction/spring/controller/OrderController.java new file mode 100644 index 0000000..f9f9041 --- /dev/null +++ b/src/main/java/ntou/auction/spring/controller/OrderController.java @@ -0,0 +1,186 @@ +package ntou.auction.spring.controller; + +import jakarta.validation.Valid; +import ntou.auction.spring.data.entity.*; +import ntou.auction.spring.data.service.*; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; + +@RestController +@RequestMapping(value = "/api/v1/order", produces = MediaType.APPLICATION_JSON_VALUE) +@CrossOrigin(origins = "http://localhost:3000") +public class OrderController { + private final OrderService orderService; + private final ProductService productService; + + private final ShoppingcartService shoppingcartService; + private final UserService userService; + + private final UserIdentity userIdentity; + + private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + private static final Map successMessage = Collections.singletonMap("message", "成功"); + private static final Map failMessage = Collections.singletonMap("message", "操作失敗"); + + private static final Map tooManySellerMessage = Collections.singletonMap("message", "訂單的賣家只能來自同一位"); + + private static final Map orderNotFound = Collections.singletonMap("message", "訂單不存在"); + + private static final Map statusError = Collections.singletonMap("message", "該狀態下無法進行操作"); + + private static final Map identityError = Collections.singletonMap("message", "該狀身分下無法進行操作"); + + private static final Map formatError = Collections.singletonMap("message", "格式錯誤"); + + private static final Map notFoundInShoppingCartError = Collections.singletonMap("message", "商品不在購物車中或購買數量過多"); + + public OrderController(OrderService orderService, ProductService productService, ShoppingcartService shoppingcartService, UserService userService, UserIdentity userIdentity) { + this.orderService = orderService; + this.productService = productService; + this.shoppingcartService = shoppingcartService; + this.userService = userService; + this.userIdentity = userIdentity; + } + + @GetMapping("/order/all") + List getAllByBuyer() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + List getOrder = orderService.findAllByBuyerId(userId); + return orderService.orderToOrderWithProductDetail(getOrder); + } + + @GetMapping("/order/reject") + List getRejectByBuyer() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findRejectByBuyerId(userId)); + } + + @GetMapping("/order/waiting") + List getWaitingByBuyer() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findWaitingByBuyerId(userId)); + } + + @GetMapping("/order/submit") + List getSubmitByBuyer() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findSubmittedByBuyerId(userId)); + } + + @GetMapping("/check") + List getWaitingBySeller() { + // filter Waited order with seller + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findWaitingBySellerId(userId)); + } + + @PostMapping("/create") + ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + List> getrequest = request.getProductList(); + // check -> -1: format error, 0: false, 1: true + Long check = shoppingcartService.checkIsProductAllInShoppingCart(getrequest, userId); + if(check.equals(-1L)) return ResponseEntity.badRequest().body(formatError); + if(check.equals(0L)) return ResponseEntity.badRequest().body(notFoundInShoppingCartError); + + // order status -> 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done + Order order = new Order(); + order.setBuyerid(userId); + order.setUpdateTime(LocalDateTime.parse(LocalDateTime.now().format(formatter), formatter)); + order.setStatus(1L); + + for (List eachProductAddAmount : getrequest) { + Long productId = eachProductAddAmount.get(0); + Long amount = eachProductAddAmount.get(1); + Product getProduct = productService.getID(productId); + // Id error + if (getProduct == null) { + Map ErrorIdMessage = Collections.singletonMap("message", "商品(ID:" + productId + ")不存在"); + return ResponseEntity.badRequest().body(ErrorIdMessage); + } + // amount exceed + if (amount > getProduct.getProductAmount()) { + Map amountExceedReturn = Collections.singletonMap("message", "商品數量(" + getProduct.getProductName() + ")過多"); + return ResponseEntity.badRequest().body(amountExceedReturn); + } + order.setSellerid(getProduct.getSellerID()); + List input = new ArrayList<>(); + input.add(productId); + input.add(amount); + order.addProductAddAmount(input); + // decrease product's amount by amount + productService.productAmountDecrease(productId, amount); + } + // delete Product amount in Shopping cart + for (List eachProductAddAmount : getrequest) { + shoppingcartService.decreaseProductByUserId(userId, eachProductAddAmount.get(0), eachProductAddAmount.get(1)); + } + boolean result = orderService.addOrder(order); + if (!result) return ResponseEntity.badRequest().body(tooManySellerMessage); + return ResponseEntity.ok(successMessage); + } + + @PostMapping("/makesubmit") + ResponseEntity> makeSubmit(@Valid @RequestBody OperateOrderRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long orderId = request.getOrderId(); + if (orderId == null) return ResponseEntity.badRequest().body(failMessage); + // result -> 0: orderNotFound, 1: statusError, 2: idError, 3: success + Long result = orderService.submitOrder(orderId, userId); + if (result.equals(0L)) return ResponseEntity.badRequest().body(orderNotFound); + if (result.equals(1L)) return ResponseEntity.badRequest().body(statusError); + if (result.equals(2L)) return ResponseEntity.badRequest().body(identityError); + return ResponseEntity.ok(successMessage); + } + + @PostMapping("/makedone") + ResponseEntity> makeDone(@Valid @RequestBody OperateOrderRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long orderId = request.getOrderId(); + if (orderId == null) return ResponseEntity.badRequest().body(failMessage); + // result -> 0: orderNotFound, 1: statusError, 2: idError, 3: success + Long result = orderService.doneOrder(orderId, userId); + if (result.equals(0L)) return ResponseEntity.badRequest().body(orderNotFound); + if (result.equals(1L)) return ResponseEntity.badRequest().body(statusError); + if (result.equals(2L)) return ResponseEntity.badRequest().body(identityError); + return ResponseEntity.ok(successMessage); + } + + @PostMapping("/makereject") + ResponseEntity> makeReject(@Valid @RequestBody OperateOrderRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long orderId = request.getOrderId(); + if (orderId == null) return ResponseEntity.badRequest().body(failMessage); + // 0: orderNotFound, 1: statusError, 2: idError, 3: success + Long result = orderService.rejectOrder(orderId, userId); + if (result.equals(0L)) return ResponseEntity.badRequest().body(orderNotFound); + if (result.equals(1L)) return ResponseEntity.badRequest().body(statusError); + if (result.equals(2L)) return ResponseEntity.badRequest().body(identityError); + boolean check = orderService.addAmountToProduct(orderService.findOrderById(orderId)); + if (!check) return ResponseEntity.badRequest().body(orderNotFound); //this may not be happened + return ResponseEntity.ok(successMessage); + } + + @PostMapping("/makecancel") + ResponseEntity> makeCancel(@Valid @RequestBody OperateOrderRequest request) { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + Long orderId = request.getOrderId(); + if (orderId == null) return ResponseEntity.badRequest().body(failMessage); + // 0: orderNotFound, 1: statusError, 2: idError, 3: success, -1: expired + Long result = orderService.cancelOrder(orderId, userId); + if (result.equals(0L)) return ResponseEntity.badRequest().body(orderNotFound); + if (result.equals(1L)) return ResponseEntity.badRequest().body(statusError); + if (result.equals(2L)) return ResponseEntity.badRequest().body(identityError); + Map expiredError = Collections.singletonMap("message", "超過7天無法取消訂單"); + if (result.equals(-1L)) return ResponseEntity.badRequest().body(expiredError); + Order thisOrder = orderService.findOrderById(orderId); + boolean check = orderService.addAmountToProduct(thisOrder); + if(!check) return ResponseEntity.badRequest().body(orderNotFound); // this may not be happened + return ResponseEntity.ok(successMessage); + } +} diff --git a/src/main/java/ntou/auction/spring/data/entity/AddOrderRequest.java b/src/main/java/ntou/auction/spring/data/entity/AddOrderRequest.java new file mode 100644 index 0000000..d0da843 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/AddOrderRequest.java @@ -0,0 +1,18 @@ +package ntou.auction.spring.data.entity; + +import ch.qos.logback.core.joran.sanity.Pair; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class AddOrderRequest { + //List -> (productid, amount) + @NotNull + List> productList; +} diff --git a/src/main/java/ntou/auction/spring/data/entity/OperateOrderRequest.java b/src/main/java/ntou/auction/spring/data/entity/OperateOrderRequest.java new file mode 100644 index 0000000..2eaf0fb --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/OperateOrderRequest.java @@ -0,0 +1,14 @@ +package ntou.auction.spring.data.entity; + +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class OperateOrderRequest { + @NotNull + Long orderId; +} diff --git a/src/main/java/ntou/auction/spring/data/entity/OrderWithProductDetail.java b/src/main/java/ntou/auction/spring/data/entity/OrderWithProductDetail.java new file mode 100644 index 0000000..a1f207c --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/OrderWithProductDetail.java @@ -0,0 +1,35 @@ +package ntou.auction.spring.data.entity; + +import ch.qos.logback.core.joran.sanity.Pair; +import com.fasterxml.jackson.annotation.JsonFormat; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import java.time.LocalDateTime; +import java.util.*; + +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +public class OrderWithProductDetail { + @NotNull + private Long orderid; + + @NotNull + private Long buyerid; + + @NotNull + private Long sellerid; + + private List productAddAmountList = new ArrayList<>(); + + @NotNull + private Long status; // 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private LocalDateTime updateTime; +} From 394a839f3f2f6d3ef6fa18bf0cac76f827fed31d Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 9 Dec 2023 21:18:26 +0800 Subject: [PATCH 099/163] Add Docker Image Builder --- .github/workflows/docker.yml | 103 +++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 .github/workflows/docker.yml diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml new file mode 100644 index 0000000..a9463a8 --- /dev/null +++ b/.github/workflows/docker.yml @@ -0,0 +1,103 @@ +name: Java CI/CD with Maven and Docker + +on: + push: + branches: + - 'development' + - 'main' +env: + REGISTRY_IMAGE: keke125/ntou-auction-java + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + platform: + - linux/amd64 + - linux/arm64 + + steps: + - uses: actions/checkout@v3 + - name: Docker meta + id: meta + uses: docker/metadata-action@v4 + with: + # list of Docker images to use as base name for tags + images: | + keke125/ntou-auction-java + - name: Set up JDK 21 + uses: actions/setup-java@v3 + with: + java-version: '21' + distribution: 'temurin' + cache: maven + - name: Build with Maven + run: ./mvnw clean package -Pproduction + - name: Set up QEMU + uses: docker/setup-qemu-action@v2 + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v2 + - name: Login to Docker Hub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + - name: Build and push by digest + id: build + uses: docker/build-push-action@v4 + with: + context: . + platforms: ${{ matrix.platform }} + labels: ${{ steps.meta.outputs.labels }} + outputs: type=image,name=${{ env.REGISTRY_IMAGE }},push-by-digest=true,name-canonical=true,push=true + - name: Export digest + run: | + mkdir -p /tmp/digests + digest="${{ steps.build.outputs.digest }}" + touch "/tmp/digests/${digest#sha256:}" + - name: Upload digest + uses: actions/upload-artifact@v3 + with: + name: digests + path: /tmp/digests/* + if-no-files-found: error + retention-days: 1 + merge: + runs-on: ubuntu-latest + needs: + - build + steps: + - + name: Download digests + uses: actions/download-artifact@v3 + with: + name: digests + path: /tmp/digests + - + name: Set up Docker Buildx + uses: docker/setup-buildx-action@v2 + - + name: Docker meta + id: meta + uses: docker/metadata-action@v4 + with: + images: ${{ env.REGISTRY_IMAGE }} + - + name: Login to Docker Hub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + - + name: Create manifest list and push + working-directory: /tmp/digests + run: | + docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \ + $(printf '${{ env.REGISTRY_IMAGE }}@sha256:%s ' *) + - + name: Inspect image + run: | + docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:${{ steps.meta.outputs.version }} From d3a1f3b5f09ada01e5b0d35ca6bbfb692a1081ba Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 9 Dec 2023 21:45:01 +0800 Subject: [PATCH 100/163] Update docker.yml --- .github/workflows/docker.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml index a9463a8..89d1fd0 100644 --- a/.github/workflows/docker.yml +++ b/.github/workflows/docker.yml @@ -35,7 +35,7 @@ jobs: distribution: 'temurin' cache: maven - name: Build with Maven - run: ./mvnw clean package -Pproduction + run: mvn -B package --file pom.xml - name: Set up QEMU uses: docker/setup-qemu-action@v2 - name: Set up Docker Buildx From bb097197ec048f925441f158fbc2fc3d4c14c27c Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 9 Dec 2023 21:51:25 +0800 Subject: [PATCH 101/163] Fix Docker Image Builder --- .github/workflows/docker.yml | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml index 89d1fd0..afa81e1 100644 --- a/.github/workflows/docker.yml +++ b/.github/workflows/docker.yml @@ -1,11 +1,13 @@ -name: Java CI/CD with Maven and Docker +name: Java CI/CD with Maven and Docker for Dev on: push: branches: - 'development' - - 'main' env: + NA_DB_URL: 'jdbc:mariadb://localhost:3306/NA' + NA_DB_USER: 'NA' + NA_DB_PASSWORD: 'NA' REGISTRY_IMAGE: keke125/ntou-auction-java jobs: @@ -34,6 +36,12 @@ jobs: java-version: '21' distribution: 'temurin' cache: maven + - name: Start MariaDB + uses: getong/mariadb-action@v1.1 + with: + mysql database: 'NA' + mysql user: 'NA' + mysql password: 'NA' - name: Build with Maven run: mvn -B package --file pom.xml - name: Set up QEMU From 6ce810727bf220460f17470994d6ccd3b9fd539d Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 9 Dec 2023 21:59:15 +0800 Subject: [PATCH 102/163] Add Dockerfile For Docker Image Builder --- Dockerfile | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Dockerfile diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..40be12d --- /dev/null +++ b/Dockerfile @@ -0,0 +1,5 @@ +FROM eclipse-temurin:21-jre + +COPY target/*.jar /app/na.jar +EXPOSE 8080 +ENTRYPOINT ["java", "-jar", "/app/na.jar"] From 7c784492f820f2ea4ad7000ffecfba71e4233d4a Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 11 Dec 2023 22:56:31 +0800 Subject: [PATCH 103/163] fix: add attribute Visible for seller to pull their product from the shelves(set visible false) --- src/main/java/ntou/auction/spring/data/entity/Product.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index 1742e15..b46f191 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -57,6 +57,8 @@ public class Product extends AbstractEntity { private Boolean isAuction; //競標商品已經被加進購物車? + private Boolean visible; + @NotNull @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") private LocalDateTime updateTime; From 35858f7c5c157d770c29151d69265a03f0b77096 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 11 Dec 2023 23:01:34 +0800 Subject: [PATCH 104/163] =?UTF-8?q?fix:=20=E8=AA=BF=E6=95=B4=E7=80=8F?= =?UTF-8?q?=E8=A6=BD=E8=88=87=E6=90=9C=E5=B0=8B=E6=A2=9D=E4=BB=B6=20?= =?UTF-8?q?=E5=BF=85=E9=A0=88=E7=82=BAvisible=20true?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ntou/auction/spring/data/service/ProductRepository.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index 784419b..2913dcd 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -17,16 +17,17 @@ public interface ProductRepository extends JpaRepository, List findAllByIsFixedPriceFalseAndIsAuctionFalse(); + List findAllByVisibleTrue(); Product findById(long id); @Query("select p from Product p " + - "where p.productName like %?1%") //string-like + "where p.productName like %?1% and p.visible = true") //string-like List findAllByFuzzyProductName(@Param("productName") String productName); // ?1:productName List findBySellerID(long ID); - List findAllByProductType(String productType); + List findAllByProductTypeAndVisibleTrue(String productType); } From 7e8100926020bf310c07cc66ae76e42dc998ec26 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 11 Dec 2023 23:06:09 +0800 Subject: [PATCH 105/163] =?UTF-8?q?feat:=20=E8=B3=A3=E5=AE=B6=E5=8F=AF?= =?UTF-8?q?=E4=BB=A5=E4=B8=8B=E6=9E=B6=E5=95=86=E5=93=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 13 +++++++++++++ .../auction/spring/data/service/ProductService.java | 13 +++++++++---- 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 39d1d49..1efb781 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -85,6 +85,7 @@ ResponseEntity> postProduct(@Valid @RequestBody PostFixedPric product.setBidIncrement(null); product.setProductAmount(request.getProductAmount()); product.setIsAuction(false); + product.setVisible(true); product.setSellerID(userService.findByUsername(userIdentity.getUsername()).getId()); product.setSellerName(userIdentity.getUsername()); @@ -113,6 +114,7 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedP product.setBidIncrement(request.getBidIncrement()); product.setProductAmount(1L); product.setIsAuction(false); + product.setVisible(true); LocalDateTime now = LocalDateTime.now(); @@ -153,6 +155,17 @@ ResponseEntity> bidProduct(@Valid @RequestBody BidRequest req return ResponseEntity.ok(successMessage); } + @DeleteMapping("/{ID}") + ResponseEntity> deleteProduct(@PathVariable long ID){ + Map successMessage = Collections.singletonMap("message","成功刪除"); + + Product p = productService.getID(ID); + p.setVisible(false); + productService.store(p); + + return ResponseEntity.ok(successMessage); + } + @PostMapping("/buy") ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequest request){ diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/data/service/ProductService.java index 107b7f4..5de58d6 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductService.java @@ -34,8 +34,8 @@ public void delete(Long id) { } */ public List list() { - return repository.findAll(); - } + return repository.findAllByVisibleTrue(); + } //browse homepage public Product getID(Long id){ return repository.findById(id).orElse(null); @@ -80,18 +80,23 @@ public void productAmountIncrease(Long id,Long increment){ product.setProductAmount(productAmount + increment); this.store(product); } + public void deleteProduct(Long id){ + Product product = this.getID(id); + product.setVisible(false); + this.store(product); + } public List findByProductName(String productName) { return repository.findAllByFuzzyProductName(productName); } public List findByProductClassification(String productType){ - return repository.findAllByProductType(productType); + return repository.findAllByProductTypeAndVisibleTrue(productType); } public List findByProductNonFixed(){ return repository.findAllByIsFixedPriceFalseAndIsAuctionFalse(); } - public List findBySellerID(Long sellerID){return repository.findBySellerID(sellerID);}//賣家中心 + public List findBySellerID(Long sellerID){return repository.findBySellerIDAndVisibleTrue(sellerID);}//賣家中心 } From 3502bc321d4666982d4ead0be3279a5fc6dde193 Mon Sep 17 00:00:00 2001 From: weichunnien Date: Mon, 11 Dec 2023 23:06:43 +0800 Subject: [PATCH 106/163] =?UTF-8?q?fix:=20=E8=B3=A3=E5=AE=B6=E4=B8=AD?= =?UTF-8?q?=E5=BF=83=E4=B8=8D=E6=9C=83=E9=A1=AF=E7=A4=BA=E8=B3=A3=E5=AE=B6?= =?UTF-8?q?=E4=B8=8B=E6=9E=B6=E4=B9=8B=E5=95=86=E5=93=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ntou/auction/spring/data/service/ProductRepository.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java index 2913dcd..b9281b5 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/ProductRepository.java @@ -25,7 +25,7 @@ public interface ProductRepository extends JpaRepository, List findAllByFuzzyProductName(@Param("productName") String productName); // ?1:productName - List findBySellerID(long ID); + List findBySellerIDAndVisibleTrue(long ID); List findAllByProductTypeAndVisibleTrue(String productType); From 1f8e8d8a297f2f32ce3e0fb1832ee200dbc2ef76 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:48:31 +0800 Subject: [PATCH 107/163] chore: Add Spring Websocket dependency for chat feature. --- pom.xml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pom.xml b/pom.xml index fb80fdb..4edf49b 100644 --- a/pom.xml +++ b/pom.xml @@ -66,6 +66,11 @@ jjwt-api 0.12.3 + + + org.springframework.boot + spring-boot-starter-websocket + io.jsonwebtoken jjwt-impl From d0462b8bb85f581286c4187148da01e0355154b2 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:53:24 +0800 Subject: [PATCH 108/163] feat: Add entity class for chat-related functionality. --- .../spring/chat/data/entity/ChatMessage.java | 25 +++++++++++++++++++ .../chat/data/entity/ChatMessageStatus.java | 5 ++++ .../chat/data/entity/ChatNotification.java | 15 +++++++++++ .../spring/chat/data/entity/ChatRoom.java | 16 ++++++++++++ 4 files changed, 61 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java new file mode 100644 index 0000000..17107ee --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java @@ -0,0 +1,25 @@ +package ntou.auction.spring.chat.data.entity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import jakarta.persistence.Entity; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; +import java.time.LocalDateTime; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ChatMessage extends AbstractEntity { + private Long senderId; + private Long receiverId; + private String senderUserName; + private String receiverUserName; + private Long chatId; + private String content; + @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") + private LocalDateTime timestamp; + private ChatMessageStatus chatMessageStatus; +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java new file mode 100644 index 0000000..2d9ef65 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java @@ -0,0 +1,5 @@ +package ntou.auction.spring.chat.data.entity; + +public enum ChatMessageStatus { + RECEIVED, DELIVERED +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java new file mode 100644 index 0000000..477d19a --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java @@ -0,0 +1,15 @@ +package ntou.auction.spring.chat.data.entity; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class ChatNotification extends AbstractEntity { + private Long id; + private Long senderId; + private String senderName; +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java new file mode 100644 index 0000000..3de0d92 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java @@ -0,0 +1,16 @@ +package ntou.auction.spring.chat.data.entity; + +import jakarta.persistence.Entity; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ChatRoom extends AbstractEntity { + private Long chatId; + private Long senderId; + private Long receiverId; +} From 44cc29ae7e171e0bdd854f9ea351b35bc91a1aad Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:54:30 +0800 Subject: [PATCH 109/163] feat: Add repository class for chat-related functionality. --- .../repository/ChatMessageRepository.java | 23 +++++++++++++++++++ .../chat/repository/ChatRoomRepository.java | 15 ++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java create mode 100644 src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java new file mode 100644 index 0000000..e33149b --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java @@ -0,0 +1,23 @@ +package ntou.auction.spring.chat.repository; + + +import jakarta.validation.constraints.NotNull; +import ntou.auction.spring.chat.data.entity.ChatMessageStatus; +import ntou.auction.spring.chat.data.entity.ChatMessage; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Query; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface ChatMessageRepository extends JpaRepository, JpaSpecificationExecutor { + + List findByChatId(@NotNull Long chatId); + + List findBySenderIdAndReceiverId(Long senderId, Long receiverId); + + Long countBySenderIdAndReceiverIdAndAndChatMessageStatus(Long senderId, Long receiverId, ChatMessageStatus ChatMessageStatus); + +} diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java new file mode 100644 index 0000000..e40289d --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java @@ -0,0 +1,15 @@ +package ntou.auction.spring.chat.repository; + +import ntou.auction.spring.chat.data.entity.ChatRoom; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.stereotype.Repository; + +import java.util.Optional; + +@Repository +public interface ChatRoomRepository extends JpaRepository, + JpaSpecificationExecutor { + + Optional findChatRoomBySenderIdAndReceiverId(Long senderId, Long receiverId); +} From bc386bd0dfe36b5ea9523c24c9f9172304bd4d04 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:55:27 +0800 Subject: [PATCH 110/163] feat: Add service class for chat-related functionality. --- .../chat/data/service/ChatMessageService.java | 70 +++++++++++++++++++ .../chat/data/service/ChatRoomService.java | 43 ++++++++++++ 2 files changed, 113 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java new file mode 100644 index 0000000..2093f4d --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java @@ -0,0 +1,70 @@ +package ntou.auction.spring.chat.data.service; + +import ntou.auction.spring.chat.data.entity.ChatMessage; +import ntou.auction.spring.chat.data.entity.ChatMessageStatus; +import ntou.auction.spring.chat.exception.MessageNotFound; +import ntou.auction.spring.chat.repository.ChatMessageRepository; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +@Service +public class ChatMessageService { + private final ChatMessageRepository repository; + private final ChatRoomService chatRoomService; + + + public ChatMessageService(ChatMessageRepository repository, ChatRoomService chatRoomService) { + this.repository = repository; + this.chatRoomService = chatRoomService; + } + + public ChatMessage save(ChatMessage chatMessage) { + chatMessage.setChatMessageStatus(ChatMessageStatus.RECEIVED); + repository.save(chatMessage); + return chatMessage; + } + + public Long countNewMessages(Long senderId, Long receiverId) { + return repository.countBySenderIdAndReceiverIdAndAndChatMessageStatus( + senderId, receiverId, ChatMessageStatus.RECEIVED); + } + + public List findChatMessages(Long senderId, Long receiverId) { + Optional chatId = chatRoomService.getChatId(senderId, receiverId, false); + + if(chatId.isEmpty()){ + return new ArrayList<>(); + } + + List messages = + chatId.map(repository::findByChatId).orElse(new ArrayList<>()); + + if(!messages.isEmpty()) { + updateStatuses(senderId, receiverId, ChatMessageStatus.DELIVERED); + } + + return messages; + } + + public ChatMessage findById(Long id) { + return repository + .findById(id) + .map(chatMessage -> { + chatMessage.setChatMessageStatus(ChatMessageStatus.DELIVERED); + return repository.save(chatMessage); + }) + .orElseThrow(() -> + new MessageNotFound("無法找到 ID為 " + id + " 的聊天紀錄")); + } + + public void updateStatuses(Long senderId, Long receiverId, ChatMessageStatus status) { + List chatMessages = repository.findBySenderIdAndReceiverId(senderId,receiverId); + for(ChatMessage chatMessage:chatMessages){ + chatMessage.setChatMessageStatus(status); + repository.save(chatMessage); + } + } +} diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java new file mode 100644 index 0000000..6252856 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java @@ -0,0 +1,43 @@ +package ntou.auction.spring.chat.data.service; + +import ntou.auction.spring.chat.data.entity.ChatRoom; +import ntou.auction.spring.chat.repository.ChatRoomRepository; +import org.springframework.stereotype.Service; + +import java.util.Optional; + +@Service +public class ChatRoomService { + private final ChatRoomRepository repository; + + public ChatRoomService(ChatRoomRepository chatRoomRepository) { + this.repository = chatRoomRepository; + } + + public Optional getChatId(Long senderId, Long receiverId, boolean createIfNotExist) { + + return repository.findChatRoomBySenderIdAndReceiverId(senderId, receiverId).map(ChatRoom::getChatId).or(() -> { + if (!createIfNotExist) { + return Optional.empty(); + } + + String chatId = String.format("%s%s", senderId, receiverId); + + ChatRoom senderRecipient = new ChatRoom(); + senderRecipient.setChatId(Long.parseLong(chatId)); + senderRecipient.setSenderId(senderId); + senderRecipient.setReceiverId(receiverId); + + repository.save(senderRecipient); + + ChatRoom recipientSender = new ChatRoom(); + recipientSender.setChatId(Long.parseLong(chatId)); + recipientSender.setSenderId(receiverId); + recipientSender.setReceiverId(senderId); + + repository.save(recipientSender); + + return Optional.of(Long.parseLong(chatId)); + }); + } +} From 2885fac20b046043605934b56480fd7047fc8e7d Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:55:58 +0800 Subject: [PATCH 111/163] feat: Add API controller class for chat-related functionality. --- .../chat/controller/ChatController.java | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/controller/ChatController.java diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java new file mode 100644 index 0000000..adf76b2 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -0,0 +1,97 @@ +package ntou.auction.spring.chat.controller; + + +import ntou.auction.spring.chat.data.entity.ChatMessage; +import ntou.auction.spring.chat.data.entity.ChatNotification; +import ntou.auction.spring.chat.data.service.ChatMessageService; +import ntou.auction.spring.chat.data.service.ChatRoomService; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; +import org.springframework.http.ResponseEntity; +import org.springframework.messaging.handler.annotation.MessageMapping; +import org.springframework.messaging.handler.annotation.Payload; +import org.springframework.messaging.simp.SimpMessagingTemplate; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; + +import java.security.Principal; +import java.time.LocalDateTime; +import java.util.Optional; + +@Controller +@CrossOrigin(origins = "http://localhost:3000") +public class ChatController { + + private final UserService userService; + + private final UserIdentity userIdentity; + + private final SimpMessagingTemplate messageTemplate; + private final ChatMessageService chatMessageService; + private final ChatRoomService chatRoomService; + + public ChatController(UserService userService, UserIdentity userIdentity, SimpMessagingTemplate messageTemplate, ChatMessageService chatMessageService, ChatRoomService chatRoomService) { + this.userService = userService; + this.userIdentity = userIdentity; + this.messageTemplate = messageTemplate; + this.chatMessageService = chatMessageService; + this.chatRoomService = chatRoomService; + } + + @MessageMapping("/send") + public void sendMessage(@Payload ChatMessage chatMessage, Principal principal) { + /* + User sender = userService.findByUsername(userIdentity.getUsername()); + ChatMessage message = new ChatMessage(); + message.setSenderId(sender.getId()); + message.setReceiverId(chatMessageRequest.getReceiverId()); + message.setContent(chatMessageRequest.getContent()); + */ + + // token無效 + if (principal.getName() == null) { + return; + } + // 傳給不存在的使用者 + if (userService.get(chatMessage.getReceiverId()).isEmpty()) { + return; + } + + Optional chatId = chatRoomService.getChatId(userService.findByUsername(principal.getName()).getId(), chatMessage.getReceiverId(), true); + System.out.println(chatId); + chatId.ifPresent(chatMessage::setChatId); + chatMessage.setSenderId(userService.findByUsername(principal.getName()).getId()); + chatMessage.setTimestamp(LocalDateTime.now()); + chatMessage.setSenderUserName(principal.getName()); + chatMessage.setReceiverUserName(userService.get(chatMessage.getReceiverId()).get().getUsername()); + ChatMessage saved = chatMessageService.save(chatMessage); + + messageTemplate.convertAndSendToUser(saved.getReceiverId().toString(), "/queue/messages", new ChatNotification( + saved.getId(), + saved.getSenderId(), + principal.getName() + )); + } + + @GetMapping("/api/v1/chat/message/{id}") + public ResponseEntity findMessage(@PathVariable Long id) { + return ResponseEntity + .ok(chatMessageService.findById(id)); + } + + @GetMapping("/api/v1/chat/messages/{recipientId}/count") + public ResponseEntity countNewMessages( + @PathVariable String recipientId) { + return ResponseEntity + .ok(chatMessageService.countNewMessages(userService.findByUsername(userIdentity.getUsername()).getId(), Long.parseLong(recipientId))); + } + + @GetMapping("/api/v1/chat/messages/{recipientId}") + public ResponseEntity findChatMessages( + @PathVariable Long recipientId) { + return ResponseEntity + .ok(chatMessageService.findChatMessages(userService.findByUsername(userIdentity.getUsername()).getId(), recipientId)); + } +} From c649024f2dff92dc2573349ffb9636c55683110a Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:58:09 +0800 Subject: [PATCH 112/163] feat: Add config class for chat-related functionality. --- .../chat/config/AuthChannelInterceptor.java | 60 ++++++++++++++++++ .../spring/chat/config/WebSocketConfig.java | 62 +++++++++++++++++++ 2 files changed, 122 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java create mode 100644 src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java diff --git a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java new file mode 100644 index 0000000..82243f7 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java @@ -0,0 +1,60 @@ +package ntou.auction.spring.chat.config; + +import io.micrometer.common.util.StringUtils; +import ntou.auction.spring.security.JWTService; +import ntou.auction.spring.security.UserDetailsServiceImpl; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; +import org.springframework.messaging.Message; +import org.springframework.messaging.MessageChannel; +import org.springframework.messaging.simp.stomp.StompCommand; +import org.springframework.messaging.simp.stomp.StompHeaderAccessor; +import org.springframework.messaging.support.ChannelInterceptor; +import org.springframework.messaging.support.MessageHeaderAccessor; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.stereotype.Component; + +import java.util.List; + +@Component +@Order(Ordered.HIGHEST_PRECEDENCE + 99) +public class AuthChannelInterceptor implements ChannelInterceptor { + + private final UserDetailsServiceImpl userDetailsServiceImpl; + + public AuthChannelInterceptor(UserDetailsServiceImpl userDetailsServiceImpl) { + this.userDetailsServiceImpl = userDetailsServiceImpl; + } + + @Override + public Message preSend(Message message, MessageChannel channel) { + StompHeaderAccessor accessor = + MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); + // 第一次連線 + if (accessor != null && StompCommand.CONNECT.equals(accessor.getCommand())) { + // 驗證token + List header = accessor.getNativeHeader("Authorization"); + // header裡面有沒有token + if (header != null && !header.isEmpty()) { + String token = header.get(0); + if (StringUtils.isNotBlank(token)) { + String username = JWTService.validateTokenAndGetUsername(token); + System.out.println("username:" + username); + // token有效 + if (username != null) { + UserDetails userDetails = userDetailsServiceImpl.loadUserByUsername(username); + Authentication authentication = + new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword()); + accessor.setUser(authentication); + return message; + } + } + } + } + System.out.println("message:" + message); + // 非第一次連線，不用驗證 + return message; + } +} diff --git a/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java b/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java new file mode 100644 index 0000000..fcba044 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java @@ -0,0 +1,62 @@ +package ntou.auction.spring.chat.config; + +import com.fasterxml.jackson.databind.ObjectMapper; +import ntou.auction.spring.security.UserDetailsServiceImpl; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; +import org.springframework.messaging.converter.DefaultContentTypeResolver; +import org.springframework.messaging.converter.MappingJackson2MessageConverter; +import org.springframework.messaging.converter.MessageConverter; +import org.springframework.messaging.simp.config.ChannelRegistration; +import org.springframework.messaging.simp.config.MessageBrokerRegistry; +import org.springframework.util.MimeTypeUtils; +import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker; +import org.springframework.web.socket.config.annotation.StompEndpointRegistry; +import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; + +import java.util.List; + +@Configuration +@EnableWebSocketMessageBroker +public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { + + private final AuthChannelInterceptor authChannelInterceptor; + + public WebSocketConfig(AuthChannelInterceptor authChannelInterceptor) { + this.authChannelInterceptor = authChannelInterceptor; + } + + @Override + public void configureMessageBroker(MessageBrokerRegistry config) { + // server端推送給client端 + config.enableSimpleBroker("/user"); + // client端發送給server端 + config.setApplicationDestinationPrefixes("/app"); + config.setUserDestinationPrefix("/user"); + } + + @Override + public void registerStompEndpoints(StompEndpointRegistry registry) { + registry.addEndpoint("/ws") + .setAllowedOrigins("*"); + //.withSockJS(); + } + + @Override + public boolean configureMessageConverters(List messageConverters) { + DefaultContentTypeResolver resolver = new DefaultContentTypeResolver(); + resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON); + MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(); + converter.setObjectMapper(new ObjectMapper()); + converter.setContentTypeResolver(resolver); + messageConverters.add(converter); + return false; + } + + @Override + public void configureClientInboundChannel(ChannelRegistration registration) { + registration.interceptors(authChannelInterceptor); + } + +} From 658cf40daaed4362aed8b17b384def66ba7b9307 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 01:01:38 +0800 Subject: [PATCH 113/163] feat: Update security configuration to allow WebSocket connections. --- .../ntou/auction/spring/security/SecurityConfiguration.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 1bc613d..cdceb7d 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -70,7 +70,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .csrf(AbstractHttpConfigurer::disable) .cors(AbstractHttpConfigurer::disable) .authorizeHttpRequests(authorize -> authorize - .requestMatchers( "/api/v1/test/**").permitAll() + .requestMatchers("/api/v1/test/**").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/sign-up").permitAll() .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() @@ -79,6 +79,8 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.POST, "/api/v1/account/users").permitAll() .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) .requestMatchers( HttpMethod.GET,"/api/v1/product/**").permitAll() + .requestMatchers( HttpMethod.POST,"/api/v1/product/**").permitAll() + .requestMatchers("/ws/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session @@ -87,7 +89,6 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { return http.build(); } - @Bean public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception { return authenticationConfiguration.getAuthenticationManager(); From 28cb66570d5ce8eb497f51a74d06403b5cab84a1 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 23:45:13 +0800 Subject: [PATCH 114/163] fix: Restrict WebSocket connections to only allow access with a valid JWT token. --- .../auction/spring/chat/config/AuthChannelInterceptor.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java index 82243f7..2084154 100644 --- a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java +++ b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java @@ -11,6 +11,7 @@ import org.springframework.messaging.simp.stomp.StompHeaderAccessor; import org.springframework.messaging.support.ChannelInterceptor; import org.springframework.messaging.support.MessageHeaderAccessor; +import org.springframework.security.access.AccessDeniedException; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.Authentication; import org.springframework.security.core.userdetails.UserDetails; @@ -49,8 +50,14 @@ public Message preSend(Message message, MessageChannel channel) { new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword()); accessor.setUser(authentication); return message; + }else{ + System.out.println("WebSocket連線驗證失敗"); + throw new AccessDeniedException("WebSocket連線驗證失敗"); } } + }else{ + System.out.println("WebSocket連線驗證失敗"); + throw new AccessDeniedException("WebSocket連線驗證失敗"); } } System.out.println("message:" + message); From 33c7def8c283f2a1b84b4822d84e001a372e3d9e Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 15:51:47 +0800 Subject: [PATCH 115/163] feat: Implement HTTP Status 404 (NOT FOUND) error handling for user-friendly error messages. --- .../spring/chat/exception/MessageNotFound.java | 12 ++++++++++++ .../RestResponseEntityExceptionHandler.java | 12 ++++++++++++ 2 files changed, 24 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java diff --git a/src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java b/src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java new file mode 100644 index 0000000..1706be2 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java @@ -0,0 +1,12 @@ +package ntou.auction.spring.chat.exception; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(HttpStatus.NOT_FOUND) +public class MessageNotFound extends RuntimeException { + + public MessageNotFound(String errorMessage){ + super(errorMessage); + } +} diff --git a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java index aaea094..4f9ebea 100644 --- a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java +++ b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java @@ -2,8 +2,10 @@ import jakarta.validation.ConstraintViolation; import jakarta.validation.ConstraintViolationException; +import ntou.auction.spring.chat.exception.MessageNotFound; import org.apache.tomcat.util.buf.StringUtils; import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatusCode; import org.springframework.http.ResponseEntity; import org.springframework.validation.FieldError; @@ -11,7 +13,9 @@ import org.springframework.web.bind.MethodArgumentNotValidException; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.ResponseStatus; import org.springframework.web.context.request.WebRequest; +import org.springframework.web.servlet.NoHandlerFoundException; import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; import java.util.*; @@ -27,6 +31,14 @@ public ResponseEntity> handleConstraintViolationException(Co return ResponseEntity.badRequest().body(response); } + @ResponseStatus(HttpStatus.NOT_FOUND) + @ExceptionHandler(MessageNotFound.class) + public ResponseEntity> handleNoHandlerFoundException(MessageNotFound ex) { + String errorMessage = ex.getMessage(); + Map response = Collections.singletonMap("message", errorMessage); + return ResponseEntity.badRequest().body(response); + } + @Override protected ResponseEntity handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) { List errors = new ArrayList<>(); From 454bde50668dae457280debcdd871227723fa05d Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 15:55:47 +0800 Subject: [PATCH 116/163] chore: Include Spring Mail and Jakarta Mail dependencies for email notification feature. --- pom.xml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/pom.xml b/pom.xml index 4edf49b..db5b79d 100644 --- a/pom.xml +++ b/pom.xml @@ -71,6 +71,15 @@ org.springframework.boot spring-boot-starter-websocket + + org.springframework.boot + spring-boot-starter-mail + + + + jakarta.mail + jakarta.mail-api + io.jsonwebtoken jjwt-impl From 062e4ce0ab3e928f5f6d131a404e6658c5f3fa8f Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 16:02:19 +0800 Subject: [PATCH 117/163] feat: Develop a Mail Service to send emails upon customer successful auction. --- .../auction/spring/mail/EmailService.java | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/mail/EmailService.java diff --git a/src/main/java/ntou/auction/spring/mail/EmailService.java b/src/main/java/ntou/auction/spring/mail/EmailService.java new file mode 100644 index 0000000..5ef146d --- /dev/null +++ b/src/main/java/ntou/auction/spring/mail/EmailService.java @@ -0,0 +1,59 @@ +package ntou.auction.spring.mail; + +import jakarta.mail.Message; +import jakarta.mail.internet.InternetAddress; +import ntou.auction.spring.core.AppConfig; +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.UserService; +import org.springframework.mail.MailException; +import org.springframework.mail.javamail.JavaMailSender; +import org.springframework.mail.javamail.MimeMessagePreparator; +import org.springframework.stereotype.Service; + +import java.util.Date; + +@Service +public class EmailService { + private final JavaMailSender mailSender; + private final UserService userService; + private final AppConfig appConfig; + + public EmailService(JavaMailSender mailSender, UserService userService, AppConfig appConfig) { + this.mailSender = mailSender; + this.userService = userService; + this.appConfig = appConfig; + } + + public void sendMailBid(Long userId, Product product) { + + if (userService.get(userId).isEmpty()) { + System.err.println("找不到ID為 " + userId + " 的使用者，無法寄出得標成功通知"); + return; + } + User customer = userService.get(userId).get(); + + MimeMessagePreparator preparator = mimeMessage -> { + mimeMessage.setSubject("[NTOU Auction] 得標通知", "UTF-8"); + mimeMessage.setRecipient(Message.RecipientType.TO, + new InternetAddress(customer.getEmail())); + mimeMessage.setFrom(new InternetAddress(appConfig.getMailUsername())); + mimeMessage.setText("親愛的 " + customer.getName() + + " (@" + customer.getUsername() + ") 您好:" + "\n" + + "您已成功標得 " + product.getProductName() + " 商品，" + + "目前商品已加入購物車，為了能夠盡早取得您心儀的商品，麻煩您盡早結帳。" + "\n\n" + + "感謝您使用 NTOU Auction，祝您購物愉快！" + "\n\n" + + "此為系統自動發送之郵件，請勿回覆!", "UTF-8" + + ); + mimeMessage.setSentDate(new Date()); + }; + + try { + this.mailSender.send(preparator); + } catch (MailException ex) { + System.err.println(ex.getMessage()); + } + } + +} From 9c621aa15683ec9c7dd08f4b433e014535488465 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 16:05:46 +0800 Subject: [PATCH 118/163] feat: Introduce application configuration for storing mail connection information. --- src/main/java/ntou/auction/spring/core/AppConfig.java | 2 ++ src/main/resources/application.properties | 9 +++++++++ 2 files changed, 11 insertions(+) diff --git a/src/main/java/ntou/auction/spring/core/AppConfig.java b/src/main/java/ntou/auction/spring/core/AppConfig.java index 78d0f9b..38bd0b1 100644 --- a/src/main/java/ntou/auction/spring/core/AppConfig.java +++ b/src/main/java/ntou/auction/spring/core/AppConfig.java @@ -33,4 +33,6 @@ public class AppConfig { // The default image size limit for new sign-up users private int newSignupImageSizeLimit; + private String mailUsername; + } \ No newline at end of file diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 5be0048..7128d7a 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -12,6 +12,14 @@ spring.datasource.driver-class-name=org.mariadb.jdbc.Driver spring.jpa.defer-datasource-initialization=true spring.sql.init.mode=always +# mail +spring.mail.host=smtp.gmail.com +spring.mail.port=587 +spring.mail.username=${NA_MAIL_USER} +spring.mail.password=${NA_MAIL_PASSWORD} +spring.mail.properties.mail.smtp.auth=true +spring.mail.properties.mail.smtp.starttls.enable=true + # upload limit # you need modify this value if you want upload bigger image spring.servlet.multipart.max-file-size=30MB @@ -32,5 +40,6 @@ app.newSignupImageSizeLimit=30 # password encoder # BCrypt pbkdf2 argon2 app.idForEncode=argon2 +app.mail-username=${NA_MAIL_USER} From c7613b16dc8743546e2b14533a8f488511a6cb1b Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 16:31:38 +0800 Subject: [PATCH 119/163] fix: Include Spring Messaging dependency. --- pom.xml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pom.xml b/pom.xml index db5b79d..f5eabeb 100644 --- a/pom.xml +++ b/pom.xml @@ -71,6 +71,10 @@ org.springframework.boot spring-boot-starter-websocket + + org.springframework + spring-messaging + org.springframework.boot spring-boot-starter-mail From 9abdbcf79409a6ede3316e9037abbf0626720572 Mon Sep 17 00:00:00 2001 From: Ray Date: Wed, 13 Dec 2023 21:58:11 +0800 Subject: [PATCH 120/163] style: change the statement of HTML bad request body and the url of getSubmitByBuyer --- .../java/ntou/auction/spring/controller/OrderController.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/OrderController.java b/src/main/java/ntou/auction/spring/controller/OrderController.java index f9f9041..aa2fce9 100644 --- a/src/main/java/ntou/auction/spring/controller/OrderController.java +++ b/src/main/java/ntou/auction/spring/controller/OrderController.java @@ -31,7 +31,7 @@ public class OrderController { private static final Map orderNotFound = Collections.singletonMap("message", "訂單不存在"); - private static final Map statusError = Collections.singletonMap("message", "該狀態下無法進行操作"); + private static final Map statusError = Collections.singletonMap("message", "無法對目前訂單進行操作"); private static final Map identityError = Collections.singletonMap("message", "該狀身分下無法進行操作"); @@ -66,7 +66,7 @@ List getWaitingByBuyer() { return orderService.orderToOrderWithProductDetail(orderService.findWaitingByBuyerId(userId)); } - @GetMapping("/order/submit") + @GetMapping("/order/accept") List getSubmitByBuyer() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); return orderService.orderToOrderWithProductDetail(orderService.findSubmittedByBuyerId(userId)); From af2a89991f5fb126996284cafcf556e0bfee9b7b Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 15 Dec 2023 20:40:35 +0800 Subject: [PATCH 121/163] =?UTF-8?q?feat:=20=E8=B3=A3=E5=AE=B6=E4=B8=AD?= =?UTF-8?q?=E5=BF=83=E4=B9=8B=E5=95=86=E5=93=81=E6=9B=B4=E6=96=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 81 ++++++++++++++++--- .../UpdateFixedPriceProductRequest.java | 41 ++++++++++ .../UpdateNonFixedPriceProductRequest.java | 48 +++++++++++ 3 files changed, 161 insertions(+), 9 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/data/entity/UpdateFixedPriceProductRequest.java create mode 100644 src/main/java/ntou/auction/spring/data/entity/UpdateNonFixedPriceProductRequest.java diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 1efb781..67f4424 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -15,6 +15,7 @@ import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.Objects; @RestController @@ -155,16 +156,7 @@ ResponseEntity> bidProduct(@Valid @RequestBody BidRequest req return ResponseEntity.ok(successMessage); } - @DeleteMapping("/{ID}") - ResponseEntity> deleteProduct(@PathVariable long ID){ - Map successMessage = Collections.singletonMap("message","成功刪除"); - - Product p = productService.getID(ID); - p.setVisible(false); - productService.store(p); - return ResponseEntity.ok(successMessage); - } @PostMapping("/buy") ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequest request){ @@ -219,4 +211,75 @@ List getProductInSellerCenter() { return productService.findBySellerID(userService.findByUsername(userIdentity.getUsername()).getId()); } + @DeleteMapping("/{ID}") + ResponseEntity> deleteProduct(@PathVariable long ID){ + Map successMessage = Collections.singletonMap("message","成功刪除"); + + Product p = productService.getID(ID); + p.setVisible(false); + productService.store(p); + + return ResponseEntity.ok(successMessage); + } + + @PutMapping("/fixedproduct/{ID}") + ResponseEntity> putFixedProduct(@PathVariable long ID , @Valid @RequestBody UpdateFixedPriceProductRequest request){ + + Map successMessage = Collections.singletonMap("message","成功更新不二價商品"); + + Product product = productService.getID(ID); + product.setProductName(request.getProductName()); + product.setProductDescription(request.getProductDescription()); + product.setProductImage(request.getProductImage()); + product.setProductType(request.getProductType()); + product.setCurrentPrice(request.getCurrentPrice()); + product.setProductAmount(request.getProductAmount()); + + productService.store(product); + return ResponseEntity.ok(successMessage); + } + + @PutMapping("/nonfixedproduct/{ID}") + ResponseEntity> putNonFixedProduct(@PathVariable long ID , @Valid @RequestBody UpdateNonFixedPriceProductRequest request){ + + Map successMessage = Collections.singletonMap("message","成功更新競標商品"); + Map failToPostponeAuction = Collections.singletonMap("message","延長競標截止時間失敗，因為有人得標嚕"); + Map fail = Collections.singletonMap("message","截止時間錯誤"); + Map failToSetUpsetPrice = Collections.singletonMap("message","底價不得更改，因為競標還在進行中"); + Map failToSetBidIncrement = Collections.singletonMap("message","每次增加金額不得更改，因為競標還在進行中"); + + Product product = productService.getID(ID); + + product.setProductName(request.getProductName()); + product.setProductDescription(request.getProductDescription()); + product.setProductImage(request.getProductImage()); + product.setProductType(request.getProductType()); + + + Map productMap= product.getBidInfo(); + if(!productMap.isEmpty() && !Objects.equals(request.getUpsetPrice(), product.getUpsetPrice())){ //map不為空，有人出價過了。且更改的底價 != 原本底價 + return ResponseEntity.badRequest().body(failToSetUpsetPrice); + } + product.setUpsetPrice(request.getUpsetPrice()); + + if(!productMap.isEmpty() && !Objects.equals(request.getBidIncrement(), product.getBidIncrement())){ //map不為空，有人出價過了。且被更改每口叫價 + return ResponseEntity.badRequest().body(failToSetBidIncrement); + } + product.setBidIncrement(request.getBidIncrement()); + + LocalDateTime now = LocalDateTime.now(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + LocalDateTime dateTime = LocalDateTime.parse(request.getFinishTime(), formatter); + if(!now.isBefore(dateTime)){ + return ResponseEntity.badRequest().body(fail); + } + if(product.getIsAuction()) { //代表競標結束且有被加入購物車 + return ResponseEntity.badRequest().body(failToPostponeAuction); + } + + product.setFinishTime(dateTime); + + productService.store(product); + return ResponseEntity.ok(successMessage); + } } diff --git a/src/main/java/ntou/auction/spring/data/entity/UpdateFixedPriceProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/UpdateFixedPriceProductRequest.java new file mode 100644 index 0000000..1a9637f --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/UpdateFixedPriceProductRequest.java @@ -0,0 +1,41 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.Lob; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class UpdateFixedPriceProductRequest { + + @NotNull + @Length(min = 1, max = 128 , message = "商品名稱至多32個中文字") + private String productName; + + @NotNull + @Min (value = 1,message = "價格須為正整數") + private Long currentPrice; + + + @Length(min = 1, max = 32) + private String productType; + + @Length(min = 1, max = 20971520,message = "商品敘述過長") + private String productDescription; + + @Lob + @Column(length = 5242880) + @Length(min = 1, max = 5242880 ,message = "圖片檔案過大，請重新上傳") + private String productImage; + + @NotNull + @Min (value = 1,message = "商品至少一個") + private Long productAmount; + +} diff --git a/src/main/java/ntou/auction/spring/data/entity/UpdateNonFixedPriceProductRequest.java b/src/main/java/ntou/auction/spring/data/entity/UpdateNonFixedPriceProductRequest.java new file mode 100644 index 0000000..b7b3ade --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/UpdateNonFixedPriceProductRequest.java @@ -0,0 +1,48 @@ +package ntou.auction.spring.data.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.Lob; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.validator.constraints.Length; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class UpdateNonFixedPriceProductRequest { + + @NotNull (message="商品名稱不得為空") + @Length(min = 1, max = 128 , message = "商品名稱至多32個中文字") + private String productName; + + @NotNull + @Min (value = 1,message = "價格須為正整數") + private Long upsetPrice; //lowest requested price + + @NotNull + @Min (value = 1,message = "每口叫價須為正整數") + private Long bidIncrement; + + @NotNull (message="商品數量不得為空") + private Long productAmount; + + @NotNull + private String finishTime; + + @Length(min = 1, max = 32) + private String productType; + + @Length(min = 1, max = 20971520,message = "商品敘述過長") + private String productDescription; + + @Lob + @Column(length = 5242880) + @Length(min = 1, max = 5242880 ,message = "圖片檔案過大，請重新上傳") + private String productImage; + + + +} From e2b01fe7cb477180df1578633eca4e9f556c874c Mon Sep 17 00:00:00 2001 From: weichunnien Date: Fri, 15 Dec 2023 20:41:13 +0800 Subject: [PATCH 122/163] =?UTF-8?q?fix:=20=E5=95=86=E5=93=81=E7=AB=B6?= =?UTF-8?q?=E6=A8=99=E7=B5=90=E6=9D=9F=E5=BE=8C=20=E5=A6=82=E6=9E=9C?= =?UTF-8?q?=E6=B2=92=E4=BA=BA=E8=B2=B7isAuction=E9=82=84=E6=98=AF=E7=82=BA?= =?UTF-8?q?false?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/ntou/auction/spring/data/service/TimerTask.java | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/main/java/ntou/auction/spring/data/service/TimerTask.java b/src/main/java/ntou/auction/spring/data/service/TimerTask.java index 2a7fac3..fd307c2 100644 --- a/src/main/java/ntou/auction/spring/data/service/TimerTask.java +++ b/src/main/java/ntou/auction/spring/data/service/TimerTask.java @@ -25,7 +25,7 @@ public void execute() { for (Product product : productList) { System.out.println(product.getId()); - if (product.isExpired()) { + if (product.isExpired()) { //競標結束 Map productMap= product.getBidInfo(); @@ -36,11 +36,6 @@ public void execute() { product.setIsAuction(true); productService.store(product); } - else { - product.setIsAuction(true); - productService.store(product); - } - } } } From f8c356458624acbf683d8e37bf39e1844232ce6e Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 15 Dec 2023 23:05:41 +0800 Subject: [PATCH 123/163] feat: Introduce Find Contact controller. --- .../spring/chat/controller/ChatController.java | 7 +++++++ .../chat/data/service/ChatMessageService.java | 17 ++++++++++++++--- .../chat/repository/ChatMessageRepository.java | 4 ++++ 3 files changed, 25 insertions(+), 3 deletions(-) diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java index adf76b2..88ea1f0 100644 --- a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -94,4 +94,11 @@ public ResponseEntity findChatMessages( return ResponseEntity .ok(chatMessageService.findChatMessages(userService.findByUsername(userIdentity.getUsername()).getId(), recipientId)); } + + @GetMapping("/api/v1/chat/contact") + public ResponseEntity findContact() { + System.out.println(userIdentity.getUsername()); + return ResponseEntity + .ok(chatMessageService.getContact(userService.findByUsername(userIdentity.getUsername()).getId())); + } } diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java index 2093f4d..fe1d613 100644 --- a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java @@ -6,9 +6,7 @@ import ntou.auction.spring.chat.repository.ChatMessageRepository; import org.springframework.stereotype.Service; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; +import java.util.*; @Service public class ChatMessageService { @@ -67,4 +65,17 @@ public void updateStatuses(Long senderId, Long receiverId, ChatMessageStatus sta repository.save(chatMessage); } } + + public Set getContact(Long userId){ + List sendByUser = repository.findAllBySenderId(userId); + List receiveByUser = repository.findAllByReceiverId(userId); + Set contact = new HashSet<>(); + for(ChatMessage message: sendByUser){ + contact.add(message.getReceiverId()); + } + for(ChatMessage message: receiveByUser){ + contact.add(message.getSenderId()); + } + return contact; + } } diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java index e33149b..949d63f 100644 --- a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java @@ -18,6 +18,10 @@ public interface ChatMessageRepository extends JpaRepository, List findBySenderIdAndReceiverId(Long senderId, Long receiverId); + List findAllBySenderId(Long senderId); + + List findAllByReceiverId(Long receiverId); + Long countBySenderIdAndReceiverIdAndAndChatMessageStatus(Long senderId, Long receiverId, ChatMessageStatus ChatMessageStatus); } From aaf703f1bac504cd21a27f55cc5f71311599f38b Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 16 Dec 2023 00:32:51 +0800 Subject: [PATCH 124/163] =?UTF-8?q?fix:=20=E6=8A=8Aapi=20=E6=90=9C?= =?UTF-8?q?=E5=B0=8B=E6=94=B9=E6=88=90pathvariable(name/classification)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 24 +++++++------------ 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 67f4424..77ca66b 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -36,25 +36,17 @@ public ProductController(ProductService productService, UserIdentity userIdentit } - @GetMapping("/product") + @GetMapping("/product/{name}") @ResponseBody - public ListgetProductName(@Valid @RequestBody ProductRequestGet request) { - - long type =Integer.parseInt(request.getSearchType()); - - if(type == 1) { //find by name - String pn = request.getProductName(); - return productService.findByProductName(pn); - } - - else if(type == 2){ //find by classification - String pt = request.getProductType(); - return productService.findByProductClassification(pt); - } - - return productService.list(); + public ListgetProductName(@PathVariable String name ) { + return productService.findByProductName(name); } + @GetMapping("/product/{classification}") + @ResponseBody + public ListgetProductClassification(@PathVariable String classification) { + return productService.findByProductClassification(classification); + } @GetMapping("/products") @ResponseBody From eae138e974b7489ef3acdd58fd2f0e8e1f6fe9dc Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 16 Dec 2023 00:39:49 +0800 Subject: [PATCH 125/163] =?UTF-8?q?fix:=20=E6=8A=8Aapi=20=E6=90=9C?= =?UTF-8?q?=E5=B0=8B=E8=AA=BF=E5=A5=BD=3D=3D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ntou/auction/spring/controller/ProductController.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 77ca66b..d91d21d 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -36,13 +36,13 @@ public ProductController(ProductService productService, UserIdentity userIdentit } - @GetMapping("/product/{name}") + @GetMapping("/product/name/{name}") @ResponseBody public ListgetProductName(@PathVariable String name ) { return productService.findByProductName(name); } - @GetMapping("/product/{classification}") + @GetMapping("/product/classification/{classification}") @ResponseBody public ListgetProductClassification(@PathVariable String classification) { return productService.findByProductClassification(classification); From 195dfb4e6a51d56d568f534d1a25e4abcacd6ce6 Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 16 Dec 2023 14:26:44 +0800 Subject: [PATCH 126/163] feat: Implement support for STOMP over SockJS. --- ...cketConfig.java => WebSocketMessageConfig.java} | 14 +++++++------- .../spring/security/SecurityConfiguration.java | 1 + 2 files changed, 8 insertions(+), 7 deletions(-) rename src/main/java/ntou/auction/spring/chat/config/{WebSocketConfig.java => WebSocketMessageConfig.java} (85%) diff --git a/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java b/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java similarity index 85% rename from src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java rename to src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java index fcba044..21b1315 100644 --- a/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java +++ b/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java @@ -1,10 +1,7 @@ package ntou.auction.spring.chat.config; import com.fasterxml.jackson.databind.ObjectMapper; -import ntou.auction.spring.security.UserDetailsServiceImpl; import org.springframework.context.annotation.Configuration; -import org.springframework.core.Ordered; -import org.springframework.core.annotation.Order; import org.springframework.messaging.converter.DefaultContentTypeResolver; import org.springframework.messaging.converter.MappingJackson2MessageConverter; import org.springframework.messaging.converter.MessageConverter; @@ -15,15 +12,16 @@ import org.springframework.web.socket.config.annotation.StompEndpointRegistry; import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; +import java.net.http.WebSocketHandshakeException; import java.util.List; @Configuration @EnableWebSocketMessageBroker -public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { +public class WebSocketMessageConfig implements WebSocketMessageBrokerConfigurer { private final AuthChannelInterceptor authChannelInterceptor; - public WebSocketConfig(AuthChannelInterceptor authChannelInterceptor) { + public WebSocketMessageConfig(AuthChannelInterceptor authChannelInterceptor) { this.authChannelInterceptor = authChannelInterceptor; } @@ -39,8 +37,10 @@ public void configureMessageBroker(MessageBrokerRegistry config) { @Override public void registerStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint("/ws") - .setAllowedOrigins("*"); - //.withSockJS(); + .setAllowedOriginPatterns("*"); + registry.addEndpoint("/sockjs") + .setAllowedOriginPatterns("*") + .withSockJS(); } @Override diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index cdceb7d..2092782 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -81,6 +81,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers( HttpMethod.GET,"/api/v1/product/**").permitAll() .requestMatchers( HttpMethod.POST,"/api/v1/product/**").permitAll() .requestMatchers("/ws/**").permitAll() + .requestMatchers("/sockjs/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session From 9c42e65b68999b16ad92bbdf415bff9d6fcddaf4 Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 16 Dec 2023 19:19:18 +0800 Subject: [PATCH 127/163] feat: Expand Find Contact controller to include contact username. --- .../spring/chat/controller/ChatController.java | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java index 88ea1f0..2cf8c59 100644 --- a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -18,7 +18,10 @@ import java.security.Principal; import java.time.LocalDateTime; +import java.util.HashMap; +import java.util.Map; import java.util.Optional; +import java.util.Set; @Controller @CrossOrigin(origins = "http://localhost:3000") @@ -97,8 +100,14 @@ public ResponseEntity findChatMessages( @GetMapping("/api/v1/chat/contact") public ResponseEntity findContact() { - System.out.println(userIdentity.getUsername()); + Set contacts = chatMessageService.getContact(userService.findByUsername(userIdentity.getUsername()).getId()); + Map contactList = new HashMap<>(); + for(Long contactId: contacts){ + if(userService.get(contactId).isPresent()) { + contactList.put(contactId, userService.get(contactId).get().getUsername()); + } + } return ResponseEntity - .ok(chatMessageService.getContact(userService.findByUsername(userIdentity.getUsername()).getId())); + .ok(contactList); } } From ecb70ad31121651ab5f46ece77e9bc65c831517d Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sat, 16 Dec 2023 21:35:46 +0800 Subject: [PATCH 128/163] =?UTF-8?q?fix:=20=E8=AA=8D=E8=AD=89user=E5=90=8D?= =?UTF-8?q?=E5=AD=97=E3=80=81=E5=88=AA=E9=99=A4=E6=99=82=E6=8A=8A=E5=95=86?= =?UTF-8?q?=E5=93=81=E6=95=B8=E9=87=8F=E8=A8=AD=E6=88=900?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../spring/controller/ProductController.java | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index d91d21d..0d356cc 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -206,8 +206,14 @@ List getProductInSellerCenter() { @DeleteMapping("/{ID}") ResponseEntity> deleteProduct(@PathVariable long ID){ Map successMessage = Collections.singletonMap("message","成功刪除"); + Map failMessage = Collections.singletonMap("message","刪錯商品嚕"); Product p = productService.getID(ID); + + if(!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), p.getSellerID())){ + return ResponseEntity.badRequest().body(failMessage); + } + p.setProductAmount(0L); p.setVisible(false); productService.store(p); @@ -218,8 +224,12 @@ ResponseEntity> deleteProduct(@PathVariable long ID){ ResponseEntity> putFixedProduct(@PathVariable long ID , @Valid @RequestBody UpdateFixedPriceProductRequest request){ Map successMessage = Collections.singletonMap("message","成功更新不二價商品"); + Map failMessage = Collections.singletonMap("message","更新錯商品嚕"); Product product = productService.getID(ID); + if(!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), product.getSellerID())){ + return ResponseEntity.badRequest().body(failMessage); + } product.setProductName(request.getProductName()); product.setProductDescription(request.getProductDescription()); product.setProductImage(request.getProductImage()); @@ -237,11 +247,14 @@ ResponseEntity> putNonFixedProduct(@PathVariable long ID , @V Map successMessage = Collections.singletonMap("message","成功更新競標商品"); Map failToPostponeAuction = Collections.singletonMap("message","延長競標截止時間失敗，因為有人得標嚕"); Map fail = Collections.singletonMap("message","截止時間錯誤"); - Map failToSetUpsetPrice = Collections.singletonMap("message","底價不得更改，因為競標還在進行中"); - Map failToSetBidIncrement = Collections.singletonMap("message","每次增加金額不得更改，因為競標還在進行中"); - + Map failToSetUpsetPrice = Collections.singletonMap("message","底價不得更改，因為有人出價了"); + Map failToSetBidIncrement = Collections.singletonMap("message","每次增加金額不得更改，因為有人出價了"); + Map failMessage = Collections.singletonMap("message","更新錯商品嚕阿"); Product product = productService.getID(ID); + if(!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), product.getSellerID())){ + return ResponseEntity.badRequest().body(failMessage); + } product.setProductName(request.getProductName()); product.setProductDescription(request.getProductDescription()); product.setProductImage(request.getProductImage()); From d89b4445d39f520d23a9fbcee512a4f32fae2fa5 Mon Sep 17 00:00:00 2001 From: keke125 Date: Sun, 17 Dec 2023 20:16:02 +0800 Subject: [PATCH 129/163] feat: implement my favorite feature. --- .../spring/controller/UserController.java | 50 ++++++++++++++++++- .../spring/data/entity/FavoriteRequest.java | 14 ++++++ .../ntou/auction/spring/data/entity/User.java | 13 ++--- .../spring/data/service/UserService.java | 47 +++++++++++++++-- 4 files changed, 111 insertions(+), 13 deletions(-) create mode 100644 src/main/java/ntou/auction/spring/data/entity/FavoriteRequest.java diff --git a/src/main/java/ntou/auction/spring/controller/UserController.java b/src/main/java/ntou/auction/spring/controller/UserController.java index f7fe881..0eb298b 100644 --- a/src/main/java/ntou/auction/spring/controller/UserController.java +++ b/src/main/java/ntou/auction/spring/controller/UserController.java @@ -1,11 +1,18 @@ package ntou.auction.spring.controller; +import jakarta.validation.Valid; +import ntou.auction.spring.data.entity.FavoriteRequest; +import ntou.auction.spring.data.entity.Product; import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.ProductService; import ntou.auction.spring.data.service.UserIdentity; import ntou.auction.spring.data.service.UserService; import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; +import java.util.*; + @RestController @RequestMapping(value = "/api/v1/account", produces = MediaType.APPLICATION_JSON_VALUE) @CrossOrigin(origins = "http://localhost:3000") @@ -13,10 +20,12 @@ public class UserController { private final UserService userService; private final UserIdentity userIdentity; + private final ProductService productService; - public UserController(UserService userService, UserIdentity userIdentity) { + public UserController(UserService userService, UserIdentity userIdentity, ProductService productService) { this.userService = userService; this.userIdentity = userIdentity; + this.productService = productService; } // for admin usage @@ -34,4 +43,43 @@ User getUserProfileByJWT() { return userService.findByUsername(userIdentity.getUsername()); } + @GetMapping("/favorite") + @ResponseBody + List getFavorite() { + Set favoriteProductIds = userService.getFavoriteProducts(userService.findByUsername(userIdentity.getUsername()).getId()); + List favoriteProducts = new ArrayList<>(); + for (Long favoriteProductId : favoriteProductIds) { + favoriteProducts.add(productService.getID(favoriteProductId)); + } + return favoriteProducts; + } + + @PostMapping("/favorite") + @ResponseBody + ResponseEntity> addFavorite(@Valid @RequestBody FavoriteRequest request) { + Map duplicatedProduct = Collections.singletonMap("message", "商品已在我的最愛"); + Map productNotFound = Collections.singletonMap("message", "找不到商品"); + Map success = Collections.singletonMap("message", "成功將商品加入我的最愛"); + if (productService.getID(request.getProductId()) == null) { + return ResponseEntity.badRequest().body(productNotFound); + } + if (userService.addFavoriteProducts(userService.findByUsername(userIdentity.getUsername()).getId(), request.getProductId())) { + return ResponseEntity.ok(success); + } else { + return ResponseEntity.badRequest().body(duplicatedProduct); + } + } + + @DeleteMapping("/favorite") + @ResponseBody + ResponseEntity> removeFavorite(@Valid @RequestBody FavoriteRequest request) { + Map failed = Collections.singletonMap("message", "因為商品不存在，無法將商品從我的最愛移除"); + Map success = Collections.singletonMap("message", "成功將商品從我的最愛移除"); + if (userService.removeFavoriteProducts(userService.findByUsername(userIdentity.getUsername()).getId(), request.getProductId())) { + return ResponseEntity.ok(success); + } else { + return ResponseEntity.badRequest().body(failed); + } + } + } diff --git a/src/main/java/ntou/auction/spring/data/entity/FavoriteRequest.java b/src/main/java/ntou/auction/spring/data/entity/FavoriteRequest.java new file mode 100644 index 0000000..671fe83 --- /dev/null +++ b/src/main/java/ntou/auction/spring/data/entity/FavoriteRequest.java @@ -0,0 +1,14 @@ +package ntou.auction.spring.data.entity; + +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class FavoriteRequest { + @NotNull + private Long productId; +} diff --git a/src/main/java/ntou/auction/spring/data/entity/User.java b/src/main/java/ntou/auction/spring/data/entity/User.java index 4b60e2e..19a2712 100644 --- a/src/main/java/ntou/auction/spring/data/entity/User.java +++ b/src/main/java/ntou/auction/spring/data/entity/User.java @@ -1,15 +1,8 @@ package ntou.auction.spring.data.entity; +import jakarta.persistence.*; import jakarta.validation.constraints.NotBlank; import ntou.auction.spring.data.Role; -import jakarta.persistence.Column; -import jakarta.persistence.ElementCollection; -import jakarta.persistence.Entity; -import jakarta.persistence.EnumType; -import jakarta.persistence.Enumerated; -import jakarta.persistence.FetchType; -import jakarta.persistence.Lob; -import jakarta.persistence.Table; import jakarta.validation.constraints.Email; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; @@ -52,6 +45,10 @@ public class User extends AbstractEntity implements UserDetails { private String avatarImageName; + @ElementCollection + @CollectionTable(name = "favorite_products") + private Set favoriteProducts; + @NotBlank(message = "電子信箱不可為空!") @Email(message = "電子信箱格式錯誤!") @Column(unique = true) diff --git a/src/main/java/ntou/auction/spring/data/service/UserService.java b/src/main/java/ntou/auction/spring/data/service/UserService.java index 2ebaa38..c96ce9f 100644 --- a/src/main/java/ntou/auction/spring/data/service/UserService.java +++ b/src/main/java/ntou/auction/spring/data/service/UserService.java @@ -1,6 +1,9 @@ package ntou.auction.spring.data.service; + import ntou.auction.spring.data.entity.User; + import java.util.Optional; +import java.util.Set; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; @@ -16,8 +19,7 @@ public class UserService { private final PasswordEncoder passwordEncoder; - - public UserService(UserRepository repository, PasswordEncoder passwordEncoder) { + public UserService(UserRepository repository, PasswordEncoder passwordEncoder) { this.repository = repository; this.passwordEncoder = passwordEncoder; } @@ -33,7 +35,7 @@ public User update(User entity) { public void delete(Long id) { Optional maybeUser = repository.findById(id); if (maybeUser.isPresent()) { - User user = maybeUser.get(); + //User user = maybeUser.get(); repository.deleteById(id); } } @@ -66,8 +68,45 @@ public boolean isEmailNonExist(String email) { return repository.findAllByEmail(email).isEmpty(); } - public User findByUsername(String userName){ + public User findByUsername(String userName) { return repository.findByUsername(userName); } + public Set getFavoriteProducts(Long userId) { + if (repository.findById(userId).isPresent()) { + return repository.findById(userId).get().getFavoriteProducts(); + } else { + return null; + } + } + + public boolean addFavoriteProducts(Long userId, Long productId) { + if (repository.findById(userId).isPresent()) { + User user = repository.findById(userId).get(); + Set favoriteProducts = user.getFavoriteProducts(); + if (!favoriteProducts.add(productId)) { + return false; + } + user.setFavoriteProducts(favoriteProducts); + repository.save(user); + return true; + } else { + return false; + } + } + + public boolean removeFavoriteProducts(Long userId, Long productId) { + if (repository.findById(userId).isPresent()) { + User user = repository.findById(userId).get(); + Set favoriteProducts = user.getFavoriteProducts(); + if (!favoriteProducts.remove(productId)) { + return false; + } + user.setFavoriteProducts(favoriteProducts); + repository.save(user); + return true; + } else { + return false; + } + } } From 6305e094f6578d37990c2b4a17ad36681b4fc92d Mon Sep 17 00:00:00 2001 From: weichunnien Date: Sun, 17 Dec 2023 22:47:10 +0800 Subject: [PATCH 130/163] =?UTF-8?q?fix:=20=E4=BF=AE=E6=AD=A3=E9=8C=AF?= =?UTF-8?q?=E8=AA=A4=E8=A8=8A=E6=81=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ntou/auction/spring/controller/ProductController.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 0d356cc..71390b3 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -154,8 +154,8 @@ ResponseEntity> bidProduct(@Valid @RequestBody BidRequest req ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequest request){ Map successMessage = Collections.singletonMap("message","成功加入購物車"); - Map notEnoughMessage = Collections.singletonMap("message","買太多嚕"); - Map errorMessage = Collections.singletonMap("message","你只能將不二價商品加入購物車"); + Map notEnoughMessage = Collections.singletonMap("message","商品剩餘數量不足"); + Map errorMessage = Collections.singletonMap("message","只能將不二價商品加入購物車"); Map productNotExistMessage = Collections.singletonMap("message", "商品不存在或無法購買"); // 商品是否存在 From a87603829dae2409dfd2b7061f7b039151085d82 Mon Sep 17 00:00:00 2001 From: keke125 Date: Mon, 18 Dec 2023 18:21:56 +0800 Subject: [PATCH 131/163] feat: Introduce Update User Profile functionality. --- .../spring/controller/UserController.java | 34 +++++++++++++++++++ .../ntou/auction/spring/data/entity/User.java | 5 +++ 2 files changed, 39 insertions(+) diff --git a/src/main/java/ntou/auction/spring/controller/UserController.java b/src/main/java/ntou/auction/spring/controller/UserController.java index 0eb298b..227c09b 100644 --- a/src/main/java/ntou/auction/spring/controller/UserController.java +++ b/src/main/java/ntou/auction/spring/controller/UserController.java @@ -7,6 +7,7 @@ import ntou.auction.spring.data.service.ProductService; import ntou.auction.spring.data.service.UserIdentity; import ntou.auction.spring.data.service.UserService; +import ntou.auction.spring.security.SignupRequest; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; @@ -82,4 +83,37 @@ ResponseEntity> removeFavorite(@Valid @RequestBody FavoriteR } } + @PatchMapping("/users") + public ResponseEntity> signUp(@Valid @RequestBody SignupRequest request) { + String successMessage = "成功更新"; + String usernameDuplicatedMessage = "更新失敗，輸入的帳號已被其他人使用!"; + String emailDuplicatedMessage = "更新失敗，輸入的電子信箱已被其他人使用!"; + String emailAndUsernameDuplicatedMessage = "更新失敗，輸入的帳號及電子信箱皆已被其他人使用!"; + String passwordMessage = "至少需要8位密碼，且不超過128位"; + Map successResponse = Collections.singletonMap("message", successMessage); + Map usernameDuplicatedResponse = Collections.singletonMap("message", usernameDuplicatedMessage); + Map emailDuplicatedResponse = Collections.singletonMap("message", emailDuplicatedMessage); + Map emailAndUsernameDuplicatedResponse = Collections.singletonMap("message", emailAndUsernameDuplicatedMessage); + Map passwordResponse = Collections.singletonMap("message", passwordMessage); + User user = userService.findByUsername(userIdentity.getUsername()); + user.setEmail(request.getEmail()); + user.setUsername(request.getUsername()); + user.setName(request.getName()); + if(request.getPassword().length() < 8 || request.getPassword().length() > 128){ + return ResponseEntity.badRequest().body(passwordResponse); + } + user.setHashedPassword(userService.getPasswordEncoder().encode(request.getPassword())); + if(!userService.isUsernameNonExist(request.getUsername())){ + if(!userService.isEmailNonExist(request.getEmail())){ + return ResponseEntity.badRequest().body(emailAndUsernameDuplicatedResponse); + } + return ResponseEntity.badRequest().body(usernameDuplicatedResponse); + } + if(!userService.isEmailNonExist(request.getEmail())){ + return ResponseEntity.badRequest().body(emailDuplicatedResponse); + } + userService.update(user); + return ResponseEntity.ok(successResponse); + } + } diff --git a/src/main/java/ntou/auction/spring/data/entity/User.java b/src/main/java/ntou/auction/spring/data/entity/User.java index 19a2712..79840ce 100644 --- a/src/main/java/ntou/auction/spring/data/entity/User.java +++ b/src/main/java/ntou/auction/spring/data/entity/User.java @@ -1,5 +1,6 @@ package ntou.auction.spring.data.entity; +import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import jakarta.validation.constraints.NotBlank; import ntou.auction.spring.data.Role; @@ -30,9 +31,13 @@ public class User extends AbstractEntity implements UserDetails { @Length(min = 1, max = 128, message = "暱稱長度限制為1~32位!") private String name; + @JsonIgnore @NotBlank(message = "密碼不可為空!") private String hashedPassword; + @JsonIgnore + private String password; + @NotNull @Enumerated(EnumType.STRING) @ElementCollection(fetch = FetchType.EAGER) From 365525f6e4c9f5e706914ec75ad550eef4c2c84e Mon Sep 17 00:00:00 2001 From: Ray Date: Mon, 18 Dec 2023 22:52:10 +0800 Subject: [PATCH 132/163] fix: resolve issue with self product purchase. --- .../spring/controller/OrderController.java | 33 +++++++++++++------ .../spring/data/service/OrderService.java | 7 ++-- .../data/service/ShoppingcartService.java | 13 +++++--- 3 files changed, 34 insertions(+), 19 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/OrderController.java b/src/main/java/ntou/auction/spring/controller/OrderController.java index aa2fce9..e7d02af 100644 --- a/src/main/java/ntou/auction/spring/controller/OrderController.java +++ b/src/main/java/ntou/auction/spring/controller/OrderController.java @@ -39,6 +39,8 @@ public class OrderController { private static final Map notFoundInShoppingCartError = Collections.singletonMap("message", "商品不在購物車中或購買數量過多"); + private static final Map selfBuyingError = Collections.singletonMap("message", "不可以購買自己的商品"); + public OrderController(OrderService orderService, ProductService productService, ShoppingcartService shoppingcartService, UserService userService, UserIdentity userIdentity) { this.orderService = orderService; this.productService = productService; @@ -83,10 +85,18 @@ List getWaitingBySeller() { ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); List> getrequest = request.getProductList(); - // check -> -1: format error, 0: false, 1: true - Long check = shoppingcartService.checkIsProductAllInShoppingCart(getrequest, userId); - if(check.equals(-1L)) return ResponseEntity.badRequest().body(formatError); - if(check.equals(0L)) return ResponseEntity.badRequest().body(notFoundInShoppingCartError); + // checkAmount -> -1: format error, 0: false, 1: true + Long checkAmount = shoppingcartService.checkIsProductAllInShoppingCart(getrequest, userId); + if(checkAmount.equals(-1L)) return ResponseEntity.badRequest().body(formatError); + if(checkAmount.equals(0L)) return ResponseEntity.badRequest().body(notFoundInShoppingCartError); + + // Same seller + boolean checkSameSeller = orderService.checkIsSameSeller(getrequest); + if(!checkSameSeller) return ResponseEntity.badRequest().body(tooManySellerMessage); + + // Self buying + boolean checkSelfBuying = shoppingcartService.checkIsViolateSelfBuying(getrequest, userId); + if(checkSelfBuying) return ResponseEntity.badRequest().body(selfBuyingError); // order status -> 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done Order order = new Order(); @@ -113,15 +123,18 @@ ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest input.add(productId); input.add(amount); order.addProductAddAmount(input); - // decrease product's amount by amount - productService.productAmountDecrease(productId, amount); } - // delete Product amount in Shopping cart for (List eachProductAddAmount : getrequest) { - shoppingcartService.decreaseProductByUserId(userId, eachProductAddAmount.get(0), eachProductAddAmount.get(1)); + Long productId = eachProductAddAmount.get(0); + Long amount = eachProductAddAmount.get(1); + + // decrease product's amount by amount + productService.productAmountDecrease(productId, amount); + + // delete Product amount in Shopping cart + shoppingcartService.decreaseProductByUserId(userId, productId, amount); } - boolean result = orderService.addOrder(order); - if (!result) return ResponseEntity.badRequest().body(tooManySellerMessage); + orderService.addOrder(order); return ResponseEntity.ok(successMessage); } diff --git a/src/main/java/ntou/auction/spring/data/service/OrderService.java b/src/main/java/ntou/auction/spring/data/service/OrderService.java index d8101c5..344a360 100644 --- a/src/main/java/ntou/auction/spring/data/service/OrderService.java +++ b/src/main/java/ntou/auction/spring/data/service/OrderService.java @@ -101,14 +101,11 @@ public Long doneOrder(Long orderId, Long userId) { return 3L; } - public boolean addOrder(Order order) { - boolean check = checkIsSameSeller(order.getProductAddAmountList()); - if(!check) return false; + public void addOrder(Order order) { repository.save(order); - return true; } - private boolean checkIsSameSeller(List> list) { + public boolean checkIsSameSeller(List> list) { Set check = new HashSet<>(); for(List productAddAmount: list) { check.add(productService.getID(productAddAmount.get(0)).getSellerID()); diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java index 665792e..1653e57 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java @@ -4,10 +4,7 @@ import ntou.auction.spring.data.entity.Shoppingcart; import org.springframework.stereotype.Service; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; @Service public class ShoppingcartService { @@ -95,4 +92,12 @@ public Long checkIsProductAllInShoppingCart(List> order, Long userid) } return 1L; } + + public boolean checkIsViolateSelfBuying(List> order, Long userid) { + for(List product: order) { + Product nowProduct = productService.getID(product.get(0)); + if(nowProduct.getSellerID().equals(userid)) return true; + } + return false; + } } From 9ae7f2441446fb6b524218e4e352a81ac3d2c9ba Mon Sep 17 00:00:00 2001 From: Ray Date: Mon, 18 Dec 2023 23:39:05 +0800 Subject: [PATCH 133/163] feat: implement View Done Order functionality in the order management system. --- .../spring/controller/OrderController.java | 48 +++++++++++++------ 1 file changed, 33 insertions(+), 15 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/OrderController.java b/src/main/java/ntou/auction/spring/controller/OrderController.java index e7d02af..673562e 100644 --- a/src/main/java/ntou/auction/spring/controller/OrderController.java +++ b/src/main/java/ntou/auction/spring/controller/OrderController.java @@ -68,12 +68,18 @@ List getWaitingByBuyer() { return orderService.orderToOrderWithProductDetail(orderService.findWaitingByBuyerId(userId)); } - @GetMapping("/order/accept") + @GetMapping("/order/submitted") List getSubmitByBuyer() { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); return orderService.orderToOrderWithProductDetail(orderService.findSubmittedByBuyerId(userId)); } + @GetMapping("/order/done") + List getDoneByBuyer() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findDoneByBuyerId(userId)); + } + @GetMapping("/check") List getWaitingBySeller() { // filter Waited order with seller @@ -85,10 +91,32 @@ List getWaitingBySeller() { ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); List> getrequest = request.getProductList(); - // checkAmount -> -1: format error, 0: false, 1: true - Long checkAmount = shoppingcartService.checkIsProductAllInShoppingCart(getrequest, userId); - if(checkAmount.equals(-1L)) return ResponseEntity.badRequest().body(formatError); - if(checkAmount.equals(0L)) return ResponseEntity.badRequest().body(notFoundInShoppingCartError); + + for (List eachProductAddAmount : getrequest) { + Long productId = eachProductAddAmount.get(0); + Product getProduct = productService.getID(productId); + // Id error + if (getProduct == null) { + Map ErrorIdMessage = Collections.singletonMap("message", "商品(ID:" + productId + ")不存在"); + return ResponseEntity.badRequest().body(ErrorIdMessage); + } + } + + // checkInShoppingCart -> -1: format error, 0: false, 1: true + Long checkInShoppingCart = shoppingcartService.checkIsProductAllInShoppingCart(getrequest, userId); + if(checkInShoppingCart.equals(-1L)) return ResponseEntity.badRequest().body(formatError); + if(checkInShoppingCart.equals(0L)) return ResponseEntity.badRequest().body(notFoundInShoppingCartError); + + for (List eachProductAddAmount : getrequest) { + Long productId = eachProductAddAmount.get(0); + Long amount = eachProductAddAmount.get(1); + Product getProduct = productService.getID(productId); + // amount exceed + if (amount > getProduct.getProductAmount()) { + Map amountExceedReturn = Collections.singletonMap("message", "商品數量(" + getProduct.getProductName() + ")過多"); + return ResponseEntity.badRequest().body(amountExceedReturn); + } + } // Same seller boolean checkSameSeller = orderService.checkIsSameSeller(getrequest); @@ -108,16 +136,6 @@ ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest Long productId = eachProductAddAmount.get(0); Long amount = eachProductAddAmount.get(1); Product getProduct = productService.getID(productId); - // Id error - if (getProduct == null) { - Map ErrorIdMessage = Collections.singletonMap("message", "商品(ID:" + productId + ")不存在"); - return ResponseEntity.badRequest().body(ErrorIdMessage); - } - // amount exceed - if (amount > getProduct.getProductAmount()) { - Map amountExceedReturn = Collections.singletonMap("message", "商品數量(" + getProduct.getProductName() + ")過多"); - return ResponseEntity.badRequest().body(amountExceedReturn); - } order.setSellerid(getProduct.getSellerID()); List input = new ArrayList<>(); input.add(productId); From fb78ac4b5f2b628a73e4e867c4c31286da78964f Mon Sep 17 00:00:00 2001 From: Ray Date: Wed, 20 Dec 2023 01:48:03 +0800 Subject: [PATCH 134/163] feat: implement Controller API for product status checking. --- .../spring/controller/OrderController.java | 27 ++++++++++++++++++- .../spring/data/service/OrderRepository.java | 11 ++++++++ .../spring/data/service/OrderService.java | 16 ++++++----- 3 files changed, 47 insertions(+), 7 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/OrderController.java b/src/main/java/ntou/auction/spring/controller/OrderController.java index 673562e..fce9882 100644 --- a/src/main/java/ntou/auction/spring/controller/OrderController.java +++ b/src/main/java/ntou/auction/spring/controller/OrderController.java @@ -80,13 +80,38 @@ List getDoneByBuyer() { return orderService.orderToOrderWithProductDetail(orderService.findDoneByBuyerId(userId)); } - @GetMapping("/check") + @GetMapping("/check/all") + List getAllBySeller() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findAllBySellerId(userId)); + } + + @GetMapping("/check/reject") + List getRejectBySeller() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findRejectBySellerId(userId)); + } + + @GetMapping("/check/waiting") List getWaitingBySeller() { // filter Waited order with seller Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); return orderService.orderToOrderWithProductDetail(orderService.findWaitingBySellerId(userId)); } + @GetMapping("/check/submitted") + List getSubmittedBySeller() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findSubmittedBySellerId(userId)); + } + + @GetMapping("/check/done") + List getDoneBySeller() { + Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); + return orderService.orderToOrderWithProductDetail(orderService.findDoneBySellerId(userId)); + } + + @PostMapping("/create") ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest request) { Long userId = userService.findByUsername(userIdentity.getUsername()).getId(); diff --git a/src/main/java/ntou/auction/spring/data/service/OrderRepository.java b/src/main/java/ntou/auction/spring/data/service/OrderRepository.java index 83a8496..09af174 100644 --- a/src/main/java/ntou/auction/spring/data/service/OrderRepository.java +++ b/src/main/java/ntou/auction/spring/data/service/OrderRepository.java @@ -28,8 +28,19 @@ public interface OrderRepository extends JpaRepository, JpaSpecific @Query(value = "select * from orders o where o.buyerid = ?1 and o.status = 3", nativeQuery = true) List findDoneByBuyerid(Long buyer); + @Query(value = "select * from orders o where o.sellerid = ?1", nativeQuery = true) + List findAllBySellerid(Long seller); + + @Query(value = "select * from orders o where o.sellerid = ?1 and o.status = 0", nativeQuery = true) + List findRejectBySellerid(Long seller); @Query(value = "select * from orders o where o.sellerid = ?1 and o.status = 1", nativeQuery = true) List findWaitingBySellerid(Long seller); + + @Query(value = "select * from orders o where o.sellerid = ?1 and o.status = 2", nativeQuery = true) + List findSubmittedBySellerid(Long seller); + + @Query(value = "select * from orders o where o.sellerid = ?1 and o.status = 3", nativeQuery = true) + List findDoneBySellerid(Long seller); @Modifying @Query(value = "insert into shoppingcart(userId, productId) values (?1, ?2)", nativeQuery = true) public void addShoppingCart(Long userId, List productId); diff --git a/src/main/java/ntou/auction/spring/data/service/OrderService.java b/src/main/java/ntou/auction/spring/data/service/OrderService.java index 344a360..0b606e6 100644 --- a/src/main/java/ntou/auction/spring/data/service/OrderService.java +++ b/src/main/java/ntou/auction/spring/data/service/OrderService.java @@ -40,17 +40,21 @@ public List findWaitingByBuyerId(Long buyerId) { return repository.findWaitingByBuyerid(buyerId); } - public List findSubmittedByBuyerId(Long buyerId) { - return repository.findSubmittedByBuyerid(buyerId); - } + public List findSubmittedByBuyerId(Long buyerId) {return repository.findSubmittedByBuyerid(buyerId);} public List findDoneByBuyerId(Long buyerId) { return repository.findDoneByBuyerid(buyerId); } - public List findWaitingBySellerId(Long sellerId) { - return repository.findWaitingBySellerid(sellerId); - } + public List findAllBySellerId(Long sellerId) { return repository.findAllBySellerid(sellerId);} + + public List findRejectBySellerId(Long sellerId) { return repository.findRejectBySellerid(sellerId); } + + public List findWaitingBySellerId(Long sellerId) { return repository.findWaitingBySellerid(sellerId);} + + public List findSubmittedBySellerId(Long sellerId) { return repository.findSubmittedBySellerid(sellerId);} + + public List findDoneBySellerId(Long sellerId) { return repository.findDoneBySellerid(sellerId);} public Long submitOrder(Long orderId, Long userId) { // for status -> 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done From d2be27b46149034f9d255f877b7d7f315f0c4fbc Mon Sep 17 00:00:00 2001 From: weichunnien Date: Wed, 20 Dec 2023 20:04:28 +0800 Subject: [PATCH 135/163] =?UTF-8?q?fix:=20=E4=BF=AE=E6=AD=A3=E9=8C=AF?= =?UTF-8?q?=E8=AA=A4=E8=A8=8A=E6=81=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/ntou/auction/spring/data/entity/Product.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/data/entity/Product.java index b46f191..7c66363 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/data/entity/Product.java @@ -1,6 +1,7 @@ package ntou.auction.spring.data.entity; import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotNull; @@ -44,6 +45,7 @@ public class Product extends AbstractEntity { //followings are non-isFixedPrice feature + @JsonIgnore @ElementCollection @CollectionTable(name = "bidInfo") private Map bidInfo; From 52225dd6d33191d9dd710f928e511b6d0cbb66c1 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 20 Dec 2023 20:56:40 +0800 Subject: [PATCH 136/163] fix: Adjust JWT Token expiration to 24 hours and update security chain. --- .../ntou/auction/spring/security/JWTService.java | 4 ++-- .../spring/security/SecurityConfiguration.java | 12 +++++------- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/src/main/java/ntou/auction/spring/security/JWTService.java b/src/main/java/ntou/auction/spring/security/JWTService.java index 2a5e782..48cb9a2 100644 --- a/src/main/java/ntou/auction/spring/security/JWTService.java +++ b/src/main/java/ntou/auction/spring/security/JWTService.java @@ -38,8 +38,8 @@ public static String generateJWT(AuthRequest request) { authentication = authenticationManager.authenticate(authentication); UserDetails userDetails = (UserDetails) authentication.getPrincipal(); // millisecond - // 2 minute - long expireTime = 2 * 60 * 1000; + // one day + long expireTime = 1440 * 60 * 1000; Date current = new Date(); Date expiration = new Date(current.getTime() + expireTime); diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 1bc613d..24264f3 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -70,15 +70,13 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .csrf(AbstractHttpConfigurer::disable) .cors(AbstractHttpConfigurer::disable) .authorizeHttpRequests(authorize -> authorize - .requestMatchers( "/api/v1/test/**").permitAll() + .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/sign-up").permitAll() - .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() - .requestMatchers(HttpMethod.GET, "/api/v1/account/users/**").authenticated() - .requestMatchers(HttpMethod.GET, "/api/v1/account/users").authenticated() - .requestMatchers(HttpMethod.POST, "/api/v1/account/users").permitAll() - .requestMatchers(HttpMethod.DELETE, "/api/v1/account/users/**").hasRole(String.valueOf(Role.ADMIN)) - .requestMatchers( HttpMethod.GET,"/api/v1/product/**").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/product/products").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/product/product/name").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/product/product/classification").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/product/{ID}").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session From 8e19a30ddf208e5289bfba0a95d10450943c474c Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:48:31 +0800 Subject: [PATCH 137/163] chore: Add Spring Websocket dependency for chat feature. --- pom.xml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pom.xml b/pom.xml index fb80fdb..4edf49b 100644 --- a/pom.xml +++ b/pom.xml @@ -66,6 +66,11 @@ jjwt-api 0.12.3 + + + org.springframework.boot + spring-boot-starter-websocket + io.jsonwebtoken jjwt-impl From cef3b2a029e6ab38f6196d0564839ac0c4338434 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:53:24 +0800 Subject: [PATCH 138/163] feat: Add entity class for chat-related functionality. --- .../spring/chat/data/entity/ChatMessage.java | 25 +++++++++++++++++++ .../chat/data/entity/ChatMessageStatus.java | 5 ++++ .../chat/data/entity/ChatNotification.java | 15 +++++++++++ .../spring/chat/data/entity/ChatRoom.java | 16 ++++++++++++ 4 files changed, 61 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java new file mode 100644 index 0000000..17107ee --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java @@ -0,0 +1,25 @@ +package ntou.auction.spring.chat.data.entity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import jakarta.persistence.Entity; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; +import java.time.LocalDateTime; + +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ChatMessage extends AbstractEntity { + private Long senderId; + private Long receiverId; + private String senderUserName; + private String receiverUserName; + private Long chatId; + private String content; + @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") + private LocalDateTime timestamp; + private ChatMessageStatus chatMessageStatus; +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java new file mode 100644 index 0000000..2d9ef65 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java @@ -0,0 +1,5 @@ +package ntou.auction.spring.chat.data.entity; + +public enum ChatMessageStatus { + RECEIVED, DELIVERED +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java new file mode 100644 index 0000000..477d19a --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java @@ -0,0 +1,15 @@ +package ntou.auction.spring.chat.data.entity; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class ChatNotification extends AbstractEntity { + private Long id; + private Long senderId; + private String senderName; +} diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java b/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java new file mode 100644 index 0000000..3de0d92 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java @@ -0,0 +1,16 @@ +package ntou.auction.spring.chat.data.entity; + +import jakarta.persistence.Entity; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ntou.auction.spring.data.entity.AbstractEntity; +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ChatRoom extends AbstractEntity { + private Long chatId; + private Long senderId; + private Long receiverId; +} From f9ebec6e2e52ce3fa150382bdc0c92f5698c84bd Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:54:30 +0800 Subject: [PATCH 139/163] feat: Add repository class for chat-related functionality. --- .../repository/ChatMessageRepository.java | 23 +++++++++++++++++++ .../chat/repository/ChatRoomRepository.java | 15 ++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java create mode 100644 src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java new file mode 100644 index 0000000..e33149b --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java @@ -0,0 +1,23 @@ +package ntou.auction.spring.chat.repository; + + +import jakarta.validation.constraints.NotNull; +import ntou.auction.spring.chat.data.entity.ChatMessageStatus; +import ntou.auction.spring.chat.data.entity.ChatMessage; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.jpa.repository.Query; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface ChatMessageRepository extends JpaRepository, JpaSpecificationExecutor { + + List findByChatId(@NotNull Long chatId); + + List findBySenderIdAndReceiverId(Long senderId, Long receiverId); + + Long countBySenderIdAndReceiverIdAndAndChatMessageStatus(Long senderId, Long receiverId, ChatMessageStatus ChatMessageStatus); + +} diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java new file mode 100644 index 0000000..e40289d --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java @@ -0,0 +1,15 @@ +package ntou.auction.spring.chat.repository; + +import ntou.auction.spring.chat.data.entity.ChatRoom; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.stereotype.Repository; + +import java.util.Optional; + +@Repository +public interface ChatRoomRepository extends JpaRepository, + JpaSpecificationExecutor { + + Optional findChatRoomBySenderIdAndReceiverId(Long senderId, Long receiverId); +} From 9cd5a6d68efce09ca77e544123ba3a41223539ad Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:55:27 +0800 Subject: [PATCH 140/163] feat: Add service class for chat-related functionality. --- .../chat/data/service/ChatMessageService.java | 70 +++++++++++++++++++ .../chat/data/service/ChatRoomService.java | 43 ++++++++++++ 2 files changed, 113 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java create mode 100644 src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java new file mode 100644 index 0000000..2093f4d --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java @@ -0,0 +1,70 @@ +package ntou.auction.spring.chat.data.service; + +import ntou.auction.spring.chat.data.entity.ChatMessage; +import ntou.auction.spring.chat.data.entity.ChatMessageStatus; +import ntou.auction.spring.chat.exception.MessageNotFound; +import ntou.auction.spring.chat.repository.ChatMessageRepository; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +@Service +public class ChatMessageService { + private final ChatMessageRepository repository; + private final ChatRoomService chatRoomService; + + + public ChatMessageService(ChatMessageRepository repository, ChatRoomService chatRoomService) { + this.repository = repository; + this.chatRoomService = chatRoomService; + } + + public ChatMessage save(ChatMessage chatMessage) { + chatMessage.setChatMessageStatus(ChatMessageStatus.RECEIVED); + repository.save(chatMessage); + return chatMessage; + } + + public Long countNewMessages(Long senderId, Long receiverId) { + return repository.countBySenderIdAndReceiverIdAndAndChatMessageStatus( + senderId, receiverId, ChatMessageStatus.RECEIVED); + } + + public List findChatMessages(Long senderId, Long receiverId) { + Optional chatId = chatRoomService.getChatId(senderId, receiverId, false); + + if(chatId.isEmpty()){ + return new ArrayList<>(); + } + + List messages = + chatId.map(repository::findByChatId).orElse(new ArrayList<>()); + + if(!messages.isEmpty()) { + updateStatuses(senderId, receiverId, ChatMessageStatus.DELIVERED); + } + + return messages; + } + + public ChatMessage findById(Long id) { + return repository + .findById(id) + .map(chatMessage -> { + chatMessage.setChatMessageStatus(ChatMessageStatus.DELIVERED); + return repository.save(chatMessage); + }) + .orElseThrow(() -> + new MessageNotFound("無法找到 ID為 " + id + " 的聊天紀錄")); + } + + public void updateStatuses(Long senderId, Long receiverId, ChatMessageStatus status) { + List chatMessages = repository.findBySenderIdAndReceiverId(senderId,receiverId); + for(ChatMessage chatMessage:chatMessages){ + chatMessage.setChatMessageStatus(status); + repository.save(chatMessage); + } + } +} diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java new file mode 100644 index 0000000..6252856 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java @@ -0,0 +1,43 @@ +package ntou.auction.spring.chat.data.service; + +import ntou.auction.spring.chat.data.entity.ChatRoom; +import ntou.auction.spring.chat.repository.ChatRoomRepository; +import org.springframework.stereotype.Service; + +import java.util.Optional; + +@Service +public class ChatRoomService { + private final ChatRoomRepository repository; + + public ChatRoomService(ChatRoomRepository chatRoomRepository) { + this.repository = chatRoomRepository; + } + + public Optional getChatId(Long senderId, Long receiverId, boolean createIfNotExist) { + + return repository.findChatRoomBySenderIdAndReceiverId(senderId, receiverId).map(ChatRoom::getChatId).or(() -> { + if (!createIfNotExist) { + return Optional.empty(); + } + + String chatId = String.format("%s%s", senderId, receiverId); + + ChatRoom senderRecipient = new ChatRoom(); + senderRecipient.setChatId(Long.parseLong(chatId)); + senderRecipient.setSenderId(senderId); + senderRecipient.setReceiverId(receiverId); + + repository.save(senderRecipient); + + ChatRoom recipientSender = new ChatRoom(); + recipientSender.setChatId(Long.parseLong(chatId)); + recipientSender.setSenderId(receiverId); + recipientSender.setReceiverId(senderId); + + repository.save(recipientSender); + + return Optional.of(Long.parseLong(chatId)); + }); + } +} From ccd528ad3d23e3ada8c7356a54f3462d0f493d4d Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:55:58 +0800 Subject: [PATCH 141/163] feat: Add API controller class for chat-related functionality. --- .../chat/controller/ChatController.java | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/controller/ChatController.java diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java new file mode 100644 index 0000000..adf76b2 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -0,0 +1,97 @@ +package ntou.auction.spring.chat.controller; + + +import ntou.auction.spring.chat.data.entity.ChatMessage; +import ntou.auction.spring.chat.data.entity.ChatNotification; +import ntou.auction.spring.chat.data.service.ChatMessageService; +import ntou.auction.spring.chat.data.service.ChatRoomService; +import ntou.auction.spring.data.service.UserIdentity; +import ntou.auction.spring.data.service.UserService; +import org.springframework.http.ResponseEntity; +import org.springframework.messaging.handler.annotation.MessageMapping; +import org.springframework.messaging.handler.annotation.Payload; +import org.springframework.messaging.simp.SimpMessagingTemplate; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; + +import java.security.Principal; +import java.time.LocalDateTime; +import java.util.Optional; + +@Controller +@CrossOrigin(origins = "http://localhost:3000") +public class ChatController { + + private final UserService userService; + + private final UserIdentity userIdentity; + + private final SimpMessagingTemplate messageTemplate; + private final ChatMessageService chatMessageService; + private final ChatRoomService chatRoomService; + + public ChatController(UserService userService, UserIdentity userIdentity, SimpMessagingTemplate messageTemplate, ChatMessageService chatMessageService, ChatRoomService chatRoomService) { + this.userService = userService; + this.userIdentity = userIdentity; + this.messageTemplate = messageTemplate; + this.chatMessageService = chatMessageService; + this.chatRoomService = chatRoomService; + } + + @MessageMapping("/send") + public void sendMessage(@Payload ChatMessage chatMessage, Principal principal) { + /* + User sender = userService.findByUsername(userIdentity.getUsername()); + ChatMessage message = new ChatMessage(); + message.setSenderId(sender.getId()); + message.setReceiverId(chatMessageRequest.getReceiverId()); + message.setContent(chatMessageRequest.getContent()); + */ + + // token無效 + if (principal.getName() == null) { + return; + } + // 傳給不存在的使用者 + if (userService.get(chatMessage.getReceiverId()).isEmpty()) { + return; + } + + Optional chatId = chatRoomService.getChatId(userService.findByUsername(principal.getName()).getId(), chatMessage.getReceiverId(), true); + System.out.println(chatId); + chatId.ifPresent(chatMessage::setChatId); + chatMessage.setSenderId(userService.findByUsername(principal.getName()).getId()); + chatMessage.setTimestamp(LocalDateTime.now()); + chatMessage.setSenderUserName(principal.getName()); + chatMessage.setReceiverUserName(userService.get(chatMessage.getReceiverId()).get().getUsername()); + ChatMessage saved = chatMessageService.save(chatMessage); + + messageTemplate.convertAndSendToUser(saved.getReceiverId().toString(), "/queue/messages", new ChatNotification( + saved.getId(), + saved.getSenderId(), + principal.getName() + )); + } + + @GetMapping("/api/v1/chat/message/{id}") + public ResponseEntity findMessage(@PathVariable Long id) { + return ResponseEntity + .ok(chatMessageService.findById(id)); + } + + @GetMapping("/api/v1/chat/messages/{recipientId}/count") + public ResponseEntity countNewMessages( + @PathVariable String recipientId) { + return ResponseEntity + .ok(chatMessageService.countNewMessages(userService.findByUsername(userIdentity.getUsername()).getId(), Long.parseLong(recipientId))); + } + + @GetMapping("/api/v1/chat/messages/{recipientId}") + public ResponseEntity findChatMessages( + @PathVariable Long recipientId) { + return ResponseEntity + .ok(chatMessageService.findChatMessages(userService.findByUsername(userIdentity.getUsername()).getId(), recipientId)); + } +} From ac4944c762a39311f33f54cf87557e453ca9a948 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 00:58:09 +0800 Subject: [PATCH 142/163] feat: Add config class for chat-related functionality. --- .../chat/config/AuthChannelInterceptor.java | 60 ++++++++++++++++++ .../spring/chat/config/WebSocketConfig.java | 62 +++++++++++++++++++ 2 files changed, 122 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java create mode 100644 src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java diff --git a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java new file mode 100644 index 0000000..82243f7 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java @@ -0,0 +1,60 @@ +package ntou.auction.spring.chat.config; + +import io.micrometer.common.util.StringUtils; +import ntou.auction.spring.security.JWTService; +import ntou.auction.spring.security.UserDetailsServiceImpl; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; +import org.springframework.messaging.Message; +import org.springframework.messaging.MessageChannel; +import org.springframework.messaging.simp.stomp.StompCommand; +import org.springframework.messaging.simp.stomp.StompHeaderAccessor; +import org.springframework.messaging.support.ChannelInterceptor; +import org.springframework.messaging.support.MessageHeaderAccessor; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.stereotype.Component; + +import java.util.List; + +@Component +@Order(Ordered.HIGHEST_PRECEDENCE + 99) +public class AuthChannelInterceptor implements ChannelInterceptor { + + private final UserDetailsServiceImpl userDetailsServiceImpl; + + public AuthChannelInterceptor(UserDetailsServiceImpl userDetailsServiceImpl) { + this.userDetailsServiceImpl = userDetailsServiceImpl; + } + + @Override + public Message preSend(Message message, MessageChannel channel) { + StompHeaderAccessor accessor = + MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); + // 第一次連線 + if (accessor != null && StompCommand.CONNECT.equals(accessor.getCommand())) { + // 驗證token + List header = accessor.getNativeHeader("Authorization"); + // header裡面有沒有token + if (header != null && !header.isEmpty()) { + String token = header.get(0); + if (StringUtils.isNotBlank(token)) { + String username = JWTService.validateTokenAndGetUsername(token); + System.out.println("username:" + username); + // token有效 + if (username != null) { + UserDetails userDetails = userDetailsServiceImpl.loadUserByUsername(username); + Authentication authentication = + new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword()); + accessor.setUser(authentication); + return message; + } + } + } + } + System.out.println("message:" + message); + // 非第一次連線，不用驗證 + return message; + } +} diff --git a/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java b/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java new file mode 100644 index 0000000..fcba044 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java @@ -0,0 +1,62 @@ +package ntou.auction.spring.chat.config; + +import com.fasterxml.jackson.databind.ObjectMapper; +import ntou.auction.spring.security.UserDetailsServiceImpl; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; +import org.springframework.messaging.converter.DefaultContentTypeResolver; +import org.springframework.messaging.converter.MappingJackson2MessageConverter; +import org.springframework.messaging.converter.MessageConverter; +import org.springframework.messaging.simp.config.ChannelRegistration; +import org.springframework.messaging.simp.config.MessageBrokerRegistry; +import org.springframework.util.MimeTypeUtils; +import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker; +import org.springframework.web.socket.config.annotation.StompEndpointRegistry; +import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; + +import java.util.List; + +@Configuration +@EnableWebSocketMessageBroker +public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { + + private final AuthChannelInterceptor authChannelInterceptor; + + public WebSocketConfig(AuthChannelInterceptor authChannelInterceptor) { + this.authChannelInterceptor = authChannelInterceptor; + } + + @Override + public void configureMessageBroker(MessageBrokerRegistry config) { + // server端推送給client端 + config.enableSimpleBroker("/user"); + // client端發送給server端 + config.setApplicationDestinationPrefixes("/app"); + config.setUserDestinationPrefix("/user"); + } + + @Override + public void registerStompEndpoints(StompEndpointRegistry registry) { + registry.addEndpoint("/ws") + .setAllowedOrigins("*"); + //.withSockJS(); + } + + @Override + public boolean configureMessageConverters(List messageConverters) { + DefaultContentTypeResolver resolver = new DefaultContentTypeResolver(); + resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON); + MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(); + converter.setObjectMapper(new ObjectMapper()); + converter.setContentTypeResolver(resolver); + messageConverters.add(converter); + return false; + } + + @Override + public void configureClientInboundChannel(ChannelRegistration registration) { + registration.interceptors(authChannelInterceptor); + } + +} From ffb1e51b6ed5d6c8f5b9acec5185a26f7707bde7 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 29 Nov 2023 23:45:13 +0800 Subject: [PATCH 143/163] fix: Restrict WebSocket connections to only allow access with a valid JWT token. --- .../auction/spring/chat/config/AuthChannelInterceptor.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java index 82243f7..2084154 100644 --- a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java +++ b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java @@ -11,6 +11,7 @@ import org.springframework.messaging.simp.stomp.StompHeaderAccessor; import org.springframework.messaging.support.ChannelInterceptor; import org.springframework.messaging.support.MessageHeaderAccessor; +import org.springframework.security.access.AccessDeniedException; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.Authentication; import org.springframework.security.core.userdetails.UserDetails; @@ -49,8 +50,14 @@ public Message preSend(Message message, MessageChannel channel) { new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword()); accessor.setUser(authentication); return message; + }else{ + System.out.println("WebSocket連線驗證失敗"); + throw new AccessDeniedException("WebSocket連線驗證失敗"); } } + }else{ + System.out.println("WebSocket連線驗證失敗"); + throw new AccessDeniedException("WebSocket連線驗證失敗"); } } System.out.println("message:" + message); From 2ac197bfa10e5f419be6b981fd5d69e01fe6a4e7 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 15:51:47 +0800 Subject: [PATCH 144/163] feat: Implement HTTP Status 404 (NOT FOUND) error handling for user-friendly error messages. --- .../spring/chat/exception/MessageNotFound.java | 12 ++++++++++++ .../RestResponseEntityExceptionHandler.java | 12 ++++++++++++ 2 files changed, 24 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java diff --git a/src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java b/src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java new file mode 100644 index 0000000..1706be2 --- /dev/null +++ b/src/main/java/ntou/auction/spring/chat/exception/MessageNotFound.java @@ -0,0 +1,12 @@ +package ntou.auction.spring.chat.exception; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(HttpStatus.NOT_FOUND) +public class MessageNotFound extends RuntimeException { + + public MessageNotFound(String errorMessage){ + super(errorMessage); + } +} diff --git a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java index aaea094..4f9ebea 100644 --- a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java +++ b/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java @@ -2,8 +2,10 @@ import jakarta.validation.ConstraintViolation; import jakarta.validation.ConstraintViolationException; +import ntou.auction.spring.chat.exception.MessageNotFound; import org.apache.tomcat.util.buf.StringUtils; import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatusCode; import org.springframework.http.ResponseEntity; import org.springframework.validation.FieldError; @@ -11,7 +13,9 @@ import org.springframework.web.bind.MethodArgumentNotValidException; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.ResponseStatus; import org.springframework.web.context.request.WebRequest; +import org.springframework.web.servlet.NoHandlerFoundException; import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; import java.util.*; @@ -27,6 +31,14 @@ public ResponseEntity> handleConstraintViolationException(Co return ResponseEntity.badRequest().body(response); } + @ResponseStatus(HttpStatus.NOT_FOUND) + @ExceptionHandler(MessageNotFound.class) + public ResponseEntity> handleNoHandlerFoundException(MessageNotFound ex) { + String errorMessage = ex.getMessage(); + Map response = Collections.singletonMap("message", errorMessage); + return ResponseEntity.badRequest().body(response); + } + @Override protected ResponseEntity handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) { List errors = new ArrayList<>(); From 6f458e8d49b67ff9457058ce83d425122f702a79 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 15:55:47 +0800 Subject: [PATCH 145/163] chore: Include Spring Mail and Jakarta Mail dependencies for email notification feature. --- pom.xml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/pom.xml b/pom.xml index 4edf49b..db5b79d 100644 --- a/pom.xml +++ b/pom.xml @@ -71,6 +71,15 @@ org.springframework.boot spring-boot-starter-websocket + + org.springframework.boot + spring-boot-starter-mail + + + + jakarta.mail + jakarta.mail-api + io.jsonwebtoken jjwt-impl From 86c4fa8c12bdb3240d3e9da8509aea8747f7d2a2 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 16:02:19 +0800 Subject: [PATCH 146/163] feat: Develop a Mail Service to send emails upon customer successful auction. --- .../auction/spring/mail/EmailService.java | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 src/main/java/ntou/auction/spring/mail/EmailService.java diff --git a/src/main/java/ntou/auction/spring/mail/EmailService.java b/src/main/java/ntou/auction/spring/mail/EmailService.java new file mode 100644 index 0000000..5ef146d --- /dev/null +++ b/src/main/java/ntou/auction/spring/mail/EmailService.java @@ -0,0 +1,59 @@ +package ntou.auction.spring.mail; + +import jakarta.mail.Message; +import jakarta.mail.internet.InternetAddress; +import ntou.auction.spring.core.AppConfig; +import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.data.service.UserService; +import org.springframework.mail.MailException; +import org.springframework.mail.javamail.JavaMailSender; +import org.springframework.mail.javamail.MimeMessagePreparator; +import org.springframework.stereotype.Service; + +import java.util.Date; + +@Service +public class EmailService { + private final JavaMailSender mailSender; + private final UserService userService; + private final AppConfig appConfig; + + public EmailService(JavaMailSender mailSender, UserService userService, AppConfig appConfig) { + this.mailSender = mailSender; + this.userService = userService; + this.appConfig = appConfig; + } + + public void sendMailBid(Long userId, Product product) { + + if (userService.get(userId).isEmpty()) { + System.err.println("找不到ID為 " + userId + " 的使用者，無法寄出得標成功通知"); + return; + } + User customer = userService.get(userId).get(); + + MimeMessagePreparator preparator = mimeMessage -> { + mimeMessage.setSubject("[NTOU Auction] 得標通知", "UTF-8"); + mimeMessage.setRecipient(Message.RecipientType.TO, + new InternetAddress(customer.getEmail())); + mimeMessage.setFrom(new InternetAddress(appConfig.getMailUsername())); + mimeMessage.setText("親愛的 " + customer.getName() + + " (@" + customer.getUsername() + ") 您好:" + "\n" + + "您已成功標得 " + product.getProductName() + " 商品，" + + "目前商品已加入購物車，為了能夠盡早取得您心儀的商品，麻煩您盡早結帳。" + "\n\n" + + "感謝您使用 NTOU Auction，祝您購物愉快！" + "\n\n" + + "此為系統自動發送之郵件，請勿回覆!", "UTF-8" + + ); + mimeMessage.setSentDate(new Date()); + }; + + try { + this.mailSender.send(preparator); + } catch (MailException ex) { + System.err.println(ex.getMessage()); + } + } + +} From a233a41a9a30fdf4a2a3a5eb4bdabcc6f00f72c3 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 16:05:46 +0800 Subject: [PATCH 147/163] feat: Introduce application configuration for storing mail connection information. --- src/main/java/ntou/auction/spring/core/AppConfig.java | 2 ++ src/main/resources/application.properties | 9 +++++++++ 2 files changed, 11 insertions(+) diff --git a/src/main/java/ntou/auction/spring/core/AppConfig.java b/src/main/java/ntou/auction/spring/core/AppConfig.java index 78d0f9b..38bd0b1 100644 --- a/src/main/java/ntou/auction/spring/core/AppConfig.java +++ b/src/main/java/ntou/auction/spring/core/AppConfig.java @@ -33,4 +33,6 @@ public class AppConfig { // The default image size limit for new sign-up users private int newSignupImageSizeLimit; + private String mailUsername; + } \ No newline at end of file diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 5be0048..7128d7a 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -12,6 +12,14 @@ spring.datasource.driver-class-name=org.mariadb.jdbc.Driver spring.jpa.defer-datasource-initialization=true spring.sql.init.mode=always +# mail +spring.mail.host=smtp.gmail.com +spring.mail.port=587 +spring.mail.username=${NA_MAIL_USER} +spring.mail.password=${NA_MAIL_PASSWORD} +spring.mail.properties.mail.smtp.auth=true +spring.mail.properties.mail.smtp.starttls.enable=true + # upload limit # you need modify this value if you want upload bigger image spring.servlet.multipart.max-file-size=30MB @@ -32,5 +40,6 @@ app.newSignupImageSizeLimit=30 # password encoder # BCrypt pbkdf2 argon2 app.idForEncode=argon2 +app.mail-username=${NA_MAIL_USER} From 484bc32bd874d9f54e5d5b607d1cf67b92f35507 Mon Sep 17 00:00:00 2001 From: keke125 Date: Tue, 28 Nov 2023 01:01:38 +0800 Subject: [PATCH 148/163] feat: Update security configuration to allow WebSocket connections. --- .../java/ntou/auction/spring/security/SecurityConfiguration.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 24264f3..3f287ad 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -77,6 +77,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.GET, "/api/v1/product/product/name").permitAll() .requestMatchers(HttpMethod.GET, "/api/v1/product/product/classification").permitAll() .requestMatchers(HttpMethod.GET, "/api/v1/product/{ID}").permitAll() + .requestMatchers("/ws/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session From 8846a8d15a31308785be0483a1e79cb38f7e60d8 Mon Sep 17 00:00:00 2001 From: keke125 Date: Wed, 13 Dec 2023 16:31:38 +0800 Subject: [PATCH 149/163] fix: Include Spring Messaging dependency. --- pom.xml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pom.xml b/pom.xml index db5b79d..f5eabeb 100644 --- a/pom.xml +++ b/pom.xml @@ -71,6 +71,10 @@ org.springframework.boot spring-boot-starter-websocket + + org.springframework + spring-messaging + org.springframework.boot spring-boot-starter-mail From 7acefaf71b3240c00305efe69fa4b09723ea7de3 Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 15 Dec 2023 23:05:41 +0800 Subject: [PATCH 150/163] feat: Introduce Find Contact controller. --- .../spring/chat/controller/ChatController.java | 7 +++++++ .../chat/data/service/ChatMessageService.java | 17 ++++++++++++++--- .../chat/repository/ChatMessageRepository.java | 4 ++++ 3 files changed, 25 insertions(+), 3 deletions(-) diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java index adf76b2..88ea1f0 100644 --- a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -94,4 +94,11 @@ public ResponseEntity findChatMessages( return ResponseEntity .ok(chatMessageService.findChatMessages(userService.findByUsername(userIdentity.getUsername()).getId(), recipientId)); } + + @GetMapping("/api/v1/chat/contact") + public ResponseEntity findContact() { + System.out.println(userIdentity.getUsername()); + return ResponseEntity + .ok(chatMessageService.getContact(userService.findByUsername(userIdentity.getUsername()).getId())); + } } diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java index 2093f4d..fe1d613 100644 --- a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java +++ b/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java @@ -6,9 +6,7 @@ import ntou.auction.spring.chat.repository.ChatMessageRepository; import org.springframework.stereotype.Service; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; +import java.util.*; @Service public class ChatMessageService { @@ -67,4 +65,17 @@ public void updateStatuses(Long senderId, Long receiverId, ChatMessageStatus sta repository.save(chatMessage); } } + + public Set getContact(Long userId){ + List sendByUser = repository.findAllBySenderId(userId); + List receiveByUser = repository.findAllByReceiverId(userId); + Set contact = new HashSet<>(); + for(ChatMessage message: sendByUser){ + contact.add(message.getReceiverId()); + } + for(ChatMessage message: receiveByUser){ + contact.add(message.getSenderId()); + } + return contact; + } } diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java index e33149b..949d63f 100644 --- a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java @@ -18,6 +18,10 @@ public interface ChatMessageRepository extends JpaRepository, List findBySenderIdAndReceiverId(Long senderId, Long receiverId); + List findAllBySenderId(Long senderId); + + List findAllByReceiverId(Long receiverId); + Long countBySenderIdAndReceiverIdAndAndChatMessageStatus(Long senderId, Long receiverId, ChatMessageStatus ChatMessageStatus); } From 71e41dbe7186f26b1e76d92bbe3be75b3f0dc17d Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 16 Dec 2023 14:26:44 +0800 Subject: [PATCH 151/163] feat: Implement support for STOMP over SockJS. --- ...cketConfig.java => WebSocketMessageConfig.java} | 14 +++++++------- .../spring/security/SecurityConfiguration.java | 1 + 2 files changed, 8 insertions(+), 7 deletions(-) rename src/main/java/ntou/auction/spring/chat/config/{WebSocketConfig.java => WebSocketMessageConfig.java} (85%) diff --git a/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java b/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java similarity index 85% rename from src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java rename to src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java index fcba044..21b1315 100644 --- a/src/main/java/ntou/auction/spring/chat/config/WebSocketConfig.java +++ b/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java @@ -1,10 +1,7 @@ package ntou.auction.spring.chat.config; import com.fasterxml.jackson.databind.ObjectMapper; -import ntou.auction.spring.security.UserDetailsServiceImpl; import org.springframework.context.annotation.Configuration; -import org.springframework.core.Ordered; -import org.springframework.core.annotation.Order; import org.springframework.messaging.converter.DefaultContentTypeResolver; import org.springframework.messaging.converter.MappingJackson2MessageConverter; import org.springframework.messaging.converter.MessageConverter; @@ -15,15 +12,16 @@ import org.springframework.web.socket.config.annotation.StompEndpointRegistry; import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; +import java.net.http.WebSocketHandshakeException; import java.util.List; @Configuration @EnableWebSocketMessageBroker -public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { +public class WebSocketMessageConfig implements WebSocketMessageBrokerConfigurer { private final AuthChannelInterceptor authChannelInterceptor; - public WebSocketConfig(AuthChannelInterceptor authChannelInterceptor) { + public WebSocketMessageConfig(AuthChannelInterceptor authChannelInterceptor) { this.authChannelInterceptor = authChannelInterceptor; } @@ -39,8 +37,10 @@ public void configureMessageBroker(MessageBrokerRegistry config) { @Override public void registerStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint("/ws") - .setAllowedOrigins("*"); - //.withSockJS(); + .setAllowedOriginPatterns("*"); + registry.addEndpoint("/sockjs") + .setAllowedOriginPatterns("*") + .withSockJS(); } @Override diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 3f287ad..48a3bdf 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -78,6 +78,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.GET, "/api/v1/product/product/classification").permitAll() .requestMatchers(HttpMethod.GET, "/api/v1/product/{ID}").permitAll() .requestMatchers("/ws/**").permitAll() + .requestMatchers("/sockjs/**").permitAll() .anyRequest().authenticated()) .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class) .sessionManagement((session) -> session From 9cebae6bace1a228d9d939e9c355df79dc5356e3 Mon Sep 17 00:00:00 2001 From: keke125 Date: Sat, 16 Dec 2023 19:19:18 +0800 Subject: [PATCH 152/163] feat: Expand Find Contact controller to include contact username. --- .../spring/chat/controller/ChatController.java | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java index 88ea1f0..2cf8c59 100644 --- a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -18,7 +18,10 @@ import java.security.Principal; import java.time.LocalDateTime; +import java.util.HashMap; +import java.util.Map; import java.util.Optional; +import java.util.Set; @Controller @CrossOrigin(origins = "http://localhost:3000") @@ -97,8 +100,14 @@ public ResponseEntity findChatMessages( @GetMapping("/api/v1/chat/contact") public ResponseEntity findContact() { - System.out.println(userIdentity.getUsername()); + Set contacts = chatMessageService.getContact(userService.findByUsername(userIdentity.getUsername()).getId()); + Map contactList = new HashMap<>(); + for(Long contactId: contacts){ + if(userService.get(contactId).isPresent()) { + contactList.put(contactId, userService.get(contactId).get().getUsername()); + } + } return ResponseEntity - .ok(chatMessageService.getContact(userService.findByUsername(userIdentity.getUsername()).getId())); + .ok(contactList); } } From c868c513b0922748e2dd71c7452b1e9c7dda0033 Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 21 Dec 2023 20:06:26 +0800 Subject: [PATCH 153/163] fix: Adjust security chain and modify product detail by ID URL for enhanced security. --- .../ntou/auction/spring/controller/ProductController.java | 2 +- .../ntou/auction/spring/security/SecurityConfiguration.java | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/controller/ProductController.java index 71390b3..8f9cc14 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/controller/ProductController.java @@ -54,7 +54,7 @@ List getProductProfile() { return productService.list(); } - @GetMapping("/{ID}") + @GetMapping("/product/{ID}") @ResponseBody Product getProduct(@PathVariable long ID) { return productService.getID(ID); diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java index 48a3bdf..6254382 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java @@ -74,9 +74,9 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { .requestMatchers(HttpMethod.POST, "/api/v1/auth/log-in").permitAll() .requestMatchers(HttpMethod.POST, "/api/v1/auth/sign-up").permitAll() .requestMatchers(HttpMethod.GET, "/api/v1/product/products").permitAll() - .requestMatchers(HttpMethod.GET, "/api/v1/product/product/name").permitAll() - .requestMatchers(HttpMethod.GET, "/api/v1/product/product/classification").permitAll() - .requestMatchers(HttpMethod.GET, "/api/v1/product/{ID}").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/product/product/name/**").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/product/product/classification/**").permitAll() + .requestMatchers(HttpMethod.GET, "/api/v1/product/product/{ID}").permitAll() .requestMatchers("/ws/**").permitAll() .requestMatchers("/sockjs/**").permitAll() .anyRequest().authenticated()) From d25df42469545767f04756ea319b3b1cd378284e Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 21 Dec 2023 20:17:33 +0800 Subject: [PATCH 154/163] chore: Adjust data.sql for production usage. --- src/main/resources/data.sql | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql index 7000ac9..ebcf5fa 100644 --- a/src/main/resources/data.sql +++ b/src/main/resources/data.sql @@ -3,32 +3,33 @@ insert into user (version, id, username, name, hashed_password, avatar_image, av values (1, 1, 'admin', 'admin', '{argon2}$argon2id$v=19$m=16384,t=2,p=1$S9swkCEbXj5O8cwbZdyrtQ$4RkxTGl3xkEfm51P/gc3FORCysPStozAsm6smOnQR18', null, null, 'admin@example.com', true, true, true, true); - +/* insert into user (version, id, username, name, hashed_password, avatar_image, avatar_image_name, email, enabled, is_account_non_expired, is_account_non_locked, is_credentials_non_expired) values (1, 2, 'shit', 'admin', '{argon2}$argon2id$v=19$m=16384,t=2,p=1$S9swkCEbXj5O8cwbZdyrtQ$4RkxTGl3xkEfm51P/gc3FORCysPStozAsm6smOnQR18', null, null, 'weichun@example.com', true, true, true, true); - +*/ insert into user_roles (user_id, roles) values (1, 'USER'); +/* insert into user_roles (user_id, roles) values (2, 'USER'); +*/ insert into user_roles (user_id, roles) values (1, 'ADMIN'); - -insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,1,'IPhone13','electronic',true,'ggggg',1,null,3,1500,"2023-11-04 19:45:00",null,null,null); +/* +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,seller_name,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image,visible) +values (1,1,'IPhone13','3C產品',true,'ggggg',1,'admin',null,3,1500,"2023-11-04 19:45:00",null,null,null,true); +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,seller_name,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image,visible) +values (1,2,'IPhone18','3C產品',true,'ggggg',1,'admin',null,3,1500,"2023-11-04 19:45:00",null,null,null,true); -/* -insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,2,'IPhone18','electronic',true,'ggggg',1057088,null,3,1500,"2023-11-04 19:45:00",null,null,null); -*/ -insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,3,'IPhone13','electronic',false,'ggggg',1,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null); +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image,visible) +values (1,3,'IPhone13','3C產品',false,'ggggg',1,1000,1,1500,"2023-11-04 19:45:00","2023-11-04 20:45:00",1000,null,true); -insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image) -values (1,4,'IPhone13','electronic',false,'ggggg',1,1000,1,1500,"2023-11-04 19:45:00","2023-11-30 18:45:00",1000,null); +insert into product (version,id,product_name,product_type,is_fixed_price,product_description,sellerid,upset_price,product_amount,current_price,update_time,finish_time,bid_increment,product_image,visible) +values (1,4,'IPhone13','3C產品',false,'ggggg',1,1000,1,1500,"2023-11-04 19:45:00","2023-11-30 18:45:00",1000,null,true); +*/ \ No newline at end of file From 7f0bde19033a37f05a6abd80aca1193d0786ca50 Mon Sep 17 00:00:00 2001 From: keke125 Date: Thu, 21 Dec 2023 21:22:42 +0800 Subject: [PATCH 155/163] refactor: Reorganize code into modules and remove unused code. --- .../spring/NtouAuctionJavaApplication.java | 2 +- .../config}/JWTRequestFilter.java | 4 +++- .../config}/SecurityConfiguration.java | 5 ++--- .../controller/AuthController.java | 14 +++++++------- .../controller/UserController.java | 16 ++++++++-------- .../auction/spring/account/entity/Role.java | 5 +++++ .../spring/{data => account}/entity/User.java | 4 ++-- .../repository}/UserRepository.java | 4 ++-- .../request}/AuthRequest.java | 2 +- .../request}/FavoriteRequest.java | 2 +- .../request}/SignupRequest.java | 2 +- .../response}/AuthResponse.java | 2 +- .../response}/UserIdentity.java | 7 ++++--- .../service}/JWTService.java | 3 ++- .../service}/UserDetailsServiceImpl.java | 6 +++--- .../service/UserService.java | 5 +++-- .../chat/config/AuthChannelInterceptor.java | 6 +++--- .../chat/config/WebSocketMessageConfig.java | 1 - .../chat/controller/ChatController.java | 19 ++++++------------- .../chat/{data => }/entity/ChatMessage.java | 4 ++-- .../{data => }/entity/ChatMessageStatus.java | 2 +- .../{data => }/entity/ChatNotification.java | 4 ++-- .../chat/{data => }/entity/ChatRoom.java | 4 ++-- .../repository/ChatMessageRepository.java | 5 ++--- .../chat/repository/ChatRoomRepository.java | 2 +- .../service/ChatMessageService.java | 6 +++--- .../{data => }/service/ChatRoomService.java | 4 ++-- .../java/ntou/auction/spring/data/Role.java | 5 ----- .../auction/spring/mail/EmailService.java | 8 ++++---- .../controller/OrderController.java | 16 ++++++++++++---- .../spring/{data => order}/entity/Order.java | 4 ++-- .../repository}/OrderRepository.java | 6 ++---- .../request}/AddOrderRequest.java | 3 +-- .../request}/OperateOrderRequest.java | 2 +- .../response}/OrderWithProductDetail.java | 4 ++-- .../{data => order}/service/OrderService.java | 15 +++++++++------ .../controller/ProductController.java | 13 +++++++------ .../{data => product}/entity/Product.java | 4 ++-- .../repository}/ProductRepository.java | 4 ++-- .../request}/BidRequest.java | 5 +---- .../request}/BuyProductRequest.java | 3 +-- .../PostFixedPriceProductRequest.java | 2 +- .../PostNonFixedPriceProductRequest.java | 2 +- .../request}/ProductRequestGet.java | 5 +---- .../UpdateFixedPriceProductRequest.java | 2 +- .../UpdateNonFixedPriceProductRequest.java | 2 +- .../service/ProductService.java | 6 +++--- .../{data => product}/service/TimerTask.java | 7 +++++-- .../controller/ShoppingcartController.java | 17 +++++++++++------ .../entity/Shoppingcart.java | 4 +++- .../repository}/ShoppingcartRepository.java | 5 ++--- .../request}/ShoppingcartRequest.java | 2 +- .../response}/ProductAddAmount.java | 4 +++- .../ProductClassificatedBySeller.java | 2 +- .../service/ShoppingcartService.java | 10 ++++++---- .../{data/entity => util}/AbstractEntity.java | 2 +- .../spring/{core => util}/AppConfig.java | 2 +- .../RestResponseEntityExceptionHandler.java | 3 +-- 58 files changed, 159 insertions(+), 150 deletions(-) rename src/main/java/ntou/auction/spring/{security => account/config}/JWTRequestFilter.java (93%) rename src/main/java/ntou/auction/spring/{security => account/config}/SecurityConfiguration.java (97%) rename src/main/java/ntou/auction/spring/{ => account}/controller/AuthController.java (90%) rename src/main/java/ntou/auction/spring/{ => account}/controller/UserController.java (92%) create mode 100644 src/main/java/ntou/auction/spring/account/entity/Role.java rename src/main/java/ntou/auction/spring/{data => account}/entity/User.java (96%) rename src/main/java/ntou/auction/spring/{data/service => account/repository}/UserRepository.java (87%) rename src/main/java/ntou/auction/spring/{security => account/request}/AuthRequest.java (86%) rename src/main/java/ntou/auction/spring/{data/entity => account/request}/FavoriteRequest.java (85%) rename src/main/java/ntou/auction/spring/{security => account/request}/SignupRequest.java (95%) rename src/main/java/ntou/auction/spring/{security => account/response}/AuthResponse.java (66%) rename src/main/java/ntou/auction/spring/{data/service => account/response}/UserIdentity.java (82%) rename src/main/java/ntou/auction/spring/{security => account/service}/JWTService.java (96%) rename src/main/java/ntou/auction/spring/{security => account/service}/UserDetailsServiceImpl.java (91%) rename src/main/java/ntou/auction/spring/{data => account}/service/UserService.java (95%) rename src/main/java/ntou/auction/spring/chat/{data => }/entity/ChatMessage.java (86%) rename src/main/java/ntou/auction/spring/chat/{data => }/entity/ChatMessageStatus.java (56%) rename src/main/java/ntou/auction/spring/chat/{data => }/entity/ChatNotification.java (72%) rename src/main/java/ntou/auction/spring/chat/{data => }/entity/ChatRoom.java (75%) rename src/main/java/ntou/auction/spring/chat/{data => }/service/ChatMessageService.java (94%) rename src/main/java/ntou/auction/spring/chat/{data => }/service/ChatRoomService.java (93%) delete mode 100644 src/main/java/ntou/auction/spring/data/Role.java rename src/main/java/ntou/auction/spring/{ => order}/controller/OrderController.java (94%) rename src/main/java/ntou/auction/spring/{data => order}/entity/Order.java (90%) rename src/main/java/ntou/auction/spring/{data/service => order/repository}/OrderRepository.java (92%) rename src/main/java/ntou/auction/spring/{data/entity => order/request}/AddOrderRequest.java (78%) rename src/main/java/ntou/auction/spring/{data/entity => order/request}/OperateOrderRequest.java (85%) rename src/main/java/ntou/auction/spring/{data/entity => order/response}/OrderWithProductDetail.java (87%) rename src/main/java/ntou/auction/spring/{data => order}/service/OrderService.java (92%) rename src/main/java/ntou/auction/spring/{ => product}/controller/ProductController.java (97%) rename src/main/java/ntou/auction/spring/{data => product}/entity/Product.java (95%) rename src/main/java/ntou/auction/spring/{data/service => product/repository}/ProductRepository.java (91%) rename src/main/java/ntou/auction/spring/{data/entity => product/request}/BidRequest.java (73%) rename src/main/java/ntou/auction/spring/{data/entity => product/request}/BuyProductRequest.java (83%) rename src/main/java/ntou/auction/spring/{data/entity => product/request}/PostFixedPriceProductRequest.java (96%) rename src/main/java/ntou/auction/spring/{data/entity => product/request}/PostNonFixedPriceProductRequest.java (96%) rename src/main/java/ntou/auction/spring/{data/entity => product/request}/ProductRequestGet.java (75%) rename src/main/java/ntou/auction/spring/{data/entity => product/request}/UpdateFixedPriceProductRequest.java (95%) rename src/main/java/ntou/auction/spring/{data/entity => product/request}/UpdateNonFixedPriceProductRequest.java (96%) rename src/main/java/ntou/auction/spring/{data => product}/service/ProductService.java (94%) rename src/main/java/ntou/auction/spring/{data => product}/service/TimerTask.java (84%) rename src/main/java/ntou/auction/spring/{ => shoppingcart}/controller/ShoppingcartController.java (89%) rename src/main/java/ntou/auction/spring/{data => shoppingcart}/entity/Shoppingcart.java (94%) rename src/main/java/ntou/auction/spring/{data/service => shoppingcart/repository}/ShoppingcartRepository.java (87%) rename src/main/java/ntou/auction/spring/{data/entity => shoppingcart/request}/ShoppingcartRequest.java (85%) rename src/main/java/ntou/auction/spring/{data/entity => shoppingcart/response}/ProductAddAmount.java (68%) rename src/main/java/ntou/auction/spring/{data/entity => shoppingcart/response}/ProductClassificatedBySeller.java (87%) rename src/main/java/ntou/auction/spring/{data => shoppingcart}/service/ShoppingcartService.java (92%) rename src/main/java/ntou/auction/spring/{data/entity => util}/AbstractEntity.java (96%) rename src/main/java/ntou/auction/spring/{core => util}/AppConfig.java (96%) rename src/main/java/ntou/auction/spring/{controller => util}/RestResponseEntityExceptionHandler.java (96%) diff --git a/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java b/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java index c032e2d..4bedc9e 100644 --- a/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java +++ b/src/main/java/ntou/auction/spring/NtouAuctionJavaApplication.java @@ -1,6 +1,6 @@ package ntou.auction.spring; -import ntou.auction.spring.data.service.UserRepository; +import ntou.auction.spring.account.repository.UserRepository; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.autoconfigure.sql.init.SqlDataSourceScriptDatabaseInitializer; diff --git a/src/main/java/ntou/auction/spring/security/JWTRequestFilter.java b/src/main/java/ntou/auction/spring/account/config/JWTRequestFilter.java similarity index 93% rename from src/main/java/ntou/auction/spring/security/JWTRequestFilter.java rename to src/main/java/ntou/auction/spring/account/config/JWTRequestFilter.java index 2009817..0aeaf71 100644 --- a/src/main/java/ntou/auction/spring/security/JWTRequestFilter.java +++ b/src/main/java/ntou/auction/spring/account/config/JWTRequestFilter.java @@ -1,9 +1,11 @@ -package ntou.auction.spring.security; +package ntou.auction.spring.account.config; import jakarta.servlet.FilterChain; import jakarta.servlet.ServletException; import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletResponse; +import ntou.auction.spring.account.service.JWTService; +import ntou.auction.spring.account.service.UserDetailsServiceImpl; import org.springframework.http.HttpHeaders; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.context.SecurityContextHolder; diff --git a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java b/src/main/java/ntou/auction/spring/account/config/SecurityConfiguration.java similarity index 97% rename from src/main/java/ntou/auction/spring/security/SecurityConfiguration.java rename to src/main/java/ntou/auction/spring/account/config/SecurityConfiguration.java index 6254382..5af12bb 100644 --- a/src/main/java/ntou/auction/spring/security/SecurityConfiguration.java +++ b/src/main/java/ntou/auction/spring/account/config/SecurityConfiguration.java @@ -1,7 +1,6 @@ -package ntou.auction.spring.security; +package ntou.auction.spring.account.config; -import ntou.auction.spring.core.AppConfig; -import ntou.auction.spring.data.Role; +import ntou.auction.spring.util.AppConfig; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.HttpMethod; diff --git a/src/main/java/ntou/auction/spring/controller/AuthController.java b/src/main/java/ntou/auction/spring/account/controller/AuthController.java similarity index 90% rename from src/main/java/ntou/auction/spring/controller/AuthController.java rename to src/main/java/ntou/auction/spring/account/controller/AuthController.java index a0c848d..ffef66b 100644 --- a/src/main/java/ntou/auction/spring/controller/AuthController.java +++ b/src/main/java/ntou/auction/spring/account/controller/AuthController.java @@ -1,12 +1,12 @@ -package ntou.auction.spring.controller; +package ntou.auction.spring.account.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.Role; -import ntou.auction.spring.data.entity.User; -import ntou.auction.spring.data.service.UserService; -import ntou.auction.spring.security.AuthRequest; -import ntou.auction.spring.security.JWTService; -import ntou.auction.spring.security.SignupRequest; +import ntou.auction.spring.account.entity.Role; +import ntou.auction.spring.account.entity.User; +import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.account.request.AuthRequest; +import ntou.auction.spring.account.service.JWTService; +import ntou.auction.spring.account.request.SignupRequest; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; diff --git a/src/main/java/ntou/auction/spring/controller/UserController.java b/src/main/java/ntou/auction/spring/account/controller/UserController.java similarity index 92% rename from src/main/java/ntou/auction/spring/controller/UserController.java rename to src/main/java/ntou/auction/spring/account/controller/UserController.java index 227c09b..237606e 100644 --- a/src/main/java/ntou/auction/spring/controller/UserController.java +++ b/src/main/java/ntou/auction/spring/account/controller/UserController.java @@ -1,13 +1,13 @@ -package ntou.auction.spring.controller; +package ntou.auction.spring.account.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.FavoriteRequest; -import ntou.auction.spring.data.entity.Product; -import ntou.auction.spring.data.entity.User; -import ntou.auction.spring.data.service.ProductService; -import ntou.auction.spring.data.service.UserIdentity; -import ntou.auction.spring.data.service.UserService; -import ntou.auction.spring.security.SignupRequest; +import ntou.auction.spring.account.request.FavoriteRequest; +import ntou.auction.spring.product.entity.Product; +import ntou.auction.spring.account.entity.User; +import ntou.auction.spring.product.service.ProductService; +import ntou.auction.spring.account.response.UserIdentity; +import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.account.request.SignupRequest; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; diff --git a/src/main/java/ntou/auction/spring/account/entity/Role.java b/src/main/java/ntou/auction/spring/account/entity/Role.java new file mode 100644 index 0000000..abaa4a5 --- /dev/null +++ b/src/main/java/ntou/auction/spring/account/entity/Role.java @@ -0,0 +1,5 @@ +package ntou.auction.spring.account.entity; + +public enum Role { + USER, ADMIN +} diff --git a/src/main/java/ntou/auction/spring/data/entity/User.java b/src/main/java/ntou/auction/spring/account/entity/User.java similarity index 96% rename from src/main/java/ntou/auction/spring/data/entity/User.java rename to src/main/java/ntou/auction/spring/account/entity/User.java index 79840ce..fea61f9 100644 --- a/src/main/java/ntou/auction/spring/data/entity/User.java +++ b/src/main/java/ntou/auction/spring/account/entity/User.java @@ -1,14 +1,14 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.account.entity; import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import jakarta.validation.constraints.NotBlank; -import ntou.auction.spring.data.Role; import jakarta.validation.constraints.Email; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; +import ntou.auction.spring.util.AbstractEntity; import org.hibernate.validator.constraints.Length; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.userdetails.UserDetails; diff --git a/src/main/java/ntou/auction/spring/data/service/UserRepository.java b/src/main/java/ntou/auction/spring/account/repository/UserRepository.java similarity index 87% rename from src/main/java/ntou/auction/spring/data/service/UserRepository.java rename to src/main/java/ntou/auction/spring/account/repository/UserRepository.java index 624c08e..06e697d 100644 --- a/src/main/java/ntou/auction/spring/data/service/UserRepository.java +++ b/src/main/java/ntou/auction/spring/account/repository/UserRepository.java @@ -1,6 +1,6 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.account.repository; -import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.account.entity.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.data.jpa.repository.Query; diff --git a/src/main/java/ntou/auction/spring/security/AuthRequest.java b/src/main/java/ntou/auction/spring/account/request/AuthRequest.java similarity index 86% rename from src/main/java/ntou/auction/spring/security/AuthRequest.java rename to src/main/java/ntou/auction/spring/account/request/AuthRequest.java index 06db39a..6a0617b 100644 --- a/src/main/java/ntou/auction/spring/security/AuthRequest.java +++ b/src/main/java/ntou/auction/spring/account/request/AuthRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.security; +package ntou.auction.spring.account.request; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; diff --git a/src/main/java/ntou/auction/spring/data/entity/FavoriteRequest.java b/src/main/java/ntou/auction/spring/account/request/FavoriteRequest.java similarity index 85% rename from src/main/java/ntou/auction/spring/data/entity/FavoriteRequest.java rename to src/main/java/ntou/auction/spring/account/request/FavoriteRequest.java index 671fe83..d8a3b0e 100644 --- a/src/main/java/ntou/auction/spring/data/entity/FavoriteRequest.java +++ b/src/main/java/ntou/auction/spring/account/request/FavoriteRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.account.request; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; diff --git a/src/main/java/ntou/auction/spring/security/SignupRequest.java b/src/main/java/ntou/auction/spring/account/request/SignupRequest.java similarity index 95% rename from src/main/java/ntou/auction/spring/security/SignupRequest.java rename to src/main/java/ntou/auction/spring/account/request/SignupRequest.java index ed10983..91c3f9a 100644 --- a/src/main/java/ntou/auction/spring/security/SignupRequest.java +++ b/src/main/java/ntou/auction/spring/account/request/SignupRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.security; +package ntou.auction.spring.account.request; import jakarta.persistence.*; import jakarta.validation.constraints.Email; diff --git a/src/main/java/ntou/auction/spring/security/AuthResponse.java b/src/main/java/ntou/auction/spring/account/response/AuthResponse.java similarity index 66% rename from src/main/java/ntou/auction/spring/security/AuthResponse.java rename to src/main/java/ntou/auction/spring/account/response/AuthResponse.java index 3d5ea58..0fc1a5c 100644 --- a/src/main/java/ntou/auction/spring/security/AuthResponse.java +++ b/src/main/java/ntou/auction/spring/account/response/AuthResponse.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.security; +package ntou.auction.spring.account.response; import lombok.Data; diff --git a/src/main/java/ntou/auction/spring/data/service/UserIdentity.java b/src/main/java/ntou/auction/spring/account/response/UserIdentity.java similarity index 82% rename from src/main/java/ntou/auction/spring/data/service/UserIdentity.java rename to src/main/java/ntou/auction/spring/account/response/UserIdentity.java index 43f2998..77f3c7d 100644 --- a/src/main/java/ntou/auction/spring/data/service/UserIdentity.java +++ b/src/main/java/ntou/auction/spring/account/response/UserIdentity.java @@ -1,7 +1,8 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.account.response; -import ntou.auction.spring.data.Role; -import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.account.entity.Role; +import ntou.auction.spring.account.entity.User; import org.springframework.security.core.Authentication; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.userdetails.UserDetails; diff --git a/src/main/java/ntou/auction/spring/security/JWTService.java b/src/main/java/ntou/auction/spring/account/service/JWTService.java similarity index 96% rename from src/main/java/ntou/auction/spring/security/JWTService.java rename to src/main/java/ntou/auction/spring/account/service/JWTService.java index 48cb9a2..a4bc4bd 100644 --- a/src/main/java/ntou/auction/spring/security/JWTService.java +++ b/src/main/java/ntou/auction/spring/account/service/JWTService.java @@ -1,8 +1,9 @@ -package ntou.auction.spring.security; +package ntou.auction.spring.account.service; import io.jsonwebtoken.*; import io.jsonwebtoken.io.Decoders; import io.jsonwebtoken.security.Keys; +import ntou.auction.spring.account.request.AuthRequest; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.Authentication; diff --git a/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java b/src/main/java/ntou/auction/spring/account/service/UserDetailsServiceImpl.java similarity index 91% rename from src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java rename to src/main/java/ntou/auction/spring/account/service/UserDetailsServiceImpl.java index 45bc3f7..e752fdd 100644 --- a/src/main/java/ntou/auction/spring/security/UserDetailsServiceImpl.java +++ b/src/main/java/ntou/auction/spring/account/service/UserDetailsServiceImpl.java @@ -1,7 +1,7 @@ -package ntou.auction.spring.security; +package ntou.auction.spring.account.service; -import ntou.auction.spring.data.entity.User; -import ntou.auction.spring.data.service.UserRepository; +import ntou.auction.spring.account.entity.User; +import ntou.auction.spring.account.repository.UserRepository; import java.util.List; import java.util.stream.Collectors; diff --git a/src/main/java/ntou/auction/spring/data/service/UserService.java b/src/main/java/ntou/auction/spring/account/service/UserService.java similarity index 95% rename from src/main/java/ntou/auction/spring/data/service/UserService.java rename to src/main/java/ntou/auction/spring/account/service/UserService.java index c96ce9f..92bd490 100644 --- a/src/main/java/ntou/auction/spring/data/service/UserService.java +++ b/src/main/java/ntou/auction/spring/account/service/UserService.java @@ -1,10 +1,11 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.account.service; -import ntou.auction.spring.data.entity.User; +import ntou.auction.spring.account.entity.User; import java.util.Optional; import java.util.Set; +import ntou.auction.spring.account.repository.UserRepository; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.domain.Specification; diff --git a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java index 2084154..c31e6d1 100644 --- a/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java +++ b/src/main/java/ntou/auction/spring/chat/config/AuthChannelInterceptor.java @@ -1,8 +1,8 @@ package ntou.auction.spring.chat.config; import io.micrometer.common.util.StringUtils; -import ntou.auction.spring.security.JWTService; -import ntou.auction.spring.security.UserDetailsServiceImpl; +import ntou.auction.spring.account.service.JWTService; +import ntou.auction.spring.account.service.UserDetailsServiceImpl; import org.springframework.core.Ordered; import org.springframework.core.annotation.Order; import org.springframework.messaging.Message; @@ -39,7 +39,7 @@ public Message preSend(Message message, MessageChannel channel) { List header = accessor.getNativeHeader("Authorization"); // header裡面有沒有token if (header != null && !header.isEmpty()) { - String token = header.get(0); + String token = header.getFirst(); if (StringUtils.isNotBlank(token)) { String username = JWTService.validateTokenAndGetUsername(token); System.out.println("username:" + username); diff --git a/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java b/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java index 21b1315..fa3ed8c 100644 --- a/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java +++ b/src/main/java/ntou/auction/spring/chat/config/WebSocketMessageConfig.java @@ -12,7 +12,6 @@ import org.springframework.web.socket.config.annotation.StompEndpointRegistry; import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; -import java.net.http.WebSocketHandshakeException; import java.util.List; @Configuration diff --git a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java index 2cf8c59..7a9c3e9 100644 --- a/src/main/java/ntou/auction/spring/chat/controller/ChatController.java +++ b/src/main/java/ntou/auction/spring/chat/controller/ChatController.java @@ -1,12 +1,12 @@ package ntou.auction.spring.chat.controller; -import ntou.auction.spring.chat.data.entity.ChatMessage; -import ntou.auction.spring.chat.data.entity.ChatNotification; -import ntou.auction.spring.chat.data.service.ChatMessageService; -import ntou.auction.spring.chat.data.service.ChatRoomService; -import ntou.auction.spring.data.service.UserIdentity; -import ntou.auction.spring.data.service.UserService; +import ntou.auction.spring.chat.entity.ChatMessage; +import ntou.auction.spring.chat.entity.ChatNotification; +import ntou.auction.spring.chat.service.ChatMessageService; +import ntou.auction.spring.chat.service.ChatRoomService; +import ntou.auction.spring.account.response.UserIdentity; +import ntou.auction.spring.account.service.UserService; import org.springframework.http.ResponseEntity; import org.springframework.messaging.handler.annotation.MessageMapping; import org.springframework.messaging.handler.annotation.Payload; @@ -45,13 +45,6 @@ public ChatController(UserService userService, UserIdentity userIdentity, SimpMe @MessageMapping("/send") public void sendMessage(@Payload ChatMessage chatMessage, Principal principal) { - /* - User sender = userService.findByUsername(userIdentity.getUsername()); - ChatMessage message = new ChatMessage(); - message.setSenderId(sender.getId()); - message.setReceiverId(chatMessageRequest.getReceiverId()); - message.setContent(chatMessageRequest.getContent()); - */ // token無效 if (principal.getName() == null) { diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java b/src/main/java/ntou/auction/spring/chat/entity/ChatMessage.java similarity index 86% rename from src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java rename to src/main/java/ntou/auction/spring/chat/entity/ChatMessage.java index 17107ee..ba28cca 100644 --- a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessage.java +++ b/src/main/java/ntou/auction/spring/chat/entity/ChatMessage.java @@ -1,11 +1,11 @@ -package ntou.auction.spring.chat.data.entity; +package ntou.auction.spring.chat.entity; import com.fasterxml.jackson.annotation.JsonFormat; import jakarta.persistence.Entity; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import ntou.auction.spring.data.entity.AbstractEntity; +import ntou.auction.spring.util.AbstractEntity; import java.time.LocalDateTime; @Entity diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java b/src/main/java/ntou/auction/spring/chat/entity/ChatMessageStatus.java similarity index 56% rename from src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java rename to src/main/java/ntou/auction/spring/chat/entity/ChatMessageStatus.java index 2d9ef65..28ee876 100644 --- a/src/main/java/ntou/auction/spring/chat/data/entity/ChatMessageStatus.java +++ b/src/main/java/ntou/auction/spring/chat/entity/ChatMessageStatus.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.chat.data.entity; +package ntou.auction.spring.chat.entity; public enum ChatMessageStatus { RECEIVED, DELIVERED diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java b/src/main/java/ntou/auction/spring/chat/entity/ChatNotification.java similarity index 72% rename from src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java rename to src/main/java/ntou/auction/spring/chat/entity/ChatNotification.java index 477d19a..bb8003b 100644 --- a/src/main/java/ntou/auction/spring/chat/data/entity/ChatNotification.java +++ b/src/main/java/ntou/auction/spring/chat/entity/ChatNotification.java @@ -1,9 +1,9 @@ -package ntou.auction.spring.chat.data.entity; +package ntou.auction.spring.chat.entity; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import ntou.auction.spring.data.entity.AbstractEntity; +import ntou.auction.spring.util.AbstractEntity; @Data @AllArgsConstructor diff --git a/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java b/src/main/java/ntou/auction/spring/chat/entity/ChatRoom.java similarity index 75% rename from src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java rename to src/main/java/ntou/auction/spring/chat/entity/ChatRoom.java index 3de0d92..534ea40 100644 --- a/src/main/java/ntou/auction/spring/chat/data/entity/ChatRoom.java +++ b/src/main/java/ntou/auction/spring/chat/entity/ChatRoom.java @@ -1,10 +1,10 @@ -package ntou.auction.spring.chat.data.entity; +package ntou.auction.spring.chat.entity; import jakarta.persistence.Entity; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import ntou.auction.spring.data.entity.AbstractEntity; +import ntou.auction.spring.util.AbstractEntity; @Entity @Data @NoArgsConstructor diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java index 949d63f..242a91d 100644 --- a/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatMessageRepository.java @@ -2,11 +2,10 @@ import jakarta.validation.constraints.NotNull; -import ntou.auction.spring.chat.data.entity.ChatMessageStatus; -import ntou.auction.spring.chat.data.entity.ChatMessage; +import ntou.auction.spring.chat.entity.ChatMessageStatus; +import ntou.auction.spring.chat.entity.ChatMessage; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; -import org.springframework.data.jpa.repository.Query; import org.springframework.stereotype.Repository; import java.util.List; diff --git a/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java index e40289d..205e778 100644 --- a/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java +++ b/src/main/java/ntou/auction/spring/chat/repository/ChatRoomRepository.java @@ -1,6 +1,6 @@ package ntou.auction.spring.chat.repository; -import ntou.auction.spring.chat.data.entity.ChatRoom; +import ntou.auction.spring.chat.entity.ChatRoom; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.stereotype.Repository; diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java b/src/main/java/ntou/auction/spring/chat/service/ChatMessageService.java similarity index 94% rename from src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java rename to src/main/java/ntou/auction/spring/chat/service/ChatMessageService.java index fe1d613..a2f4354 100644 --- a/src/main/java/ntou/auction/spring/chat/data/service/ChatMessageService.java +++ b/src/main/java/ntou/auction/spring/chat/service/ChatMessageService.java @@ -1,7 +1,7 @@ -package ntou.auction.spring.chat.data.service; +package ntou.auction.spring.chat.service; -import ntou.auction.spring.chat.data.entity.ChatMessage; -import ntou.auction.spring.chat.data.entity.ChatMessageStatus; +import ntou.auction.spring.chat.entity.ChatMessage; +import ntou.auction.spring.chat.entity.ChatMessageStatus; import ntou.auction.spring.chat.exception.MessageNotFound; import ntou.auction.spring.chat.repository.ChatMessageRepository; import org.springframework.stereotype.Service; diff --git a/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java b/src/main/java/ntou/auction/spring/chat/service/ChatRoomService.java similarity index 93% rename from src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java rename to src/main/java/ntou/auction/spring/chat/service/ChatRoomService.java index 6252856..3334105 100644 --- a/src/main/java/ntou/auction/spring/chat/data/service/ChatRoomService.java +++ b/src/main/java/ntou/auction/spring/chat/service/ChatRoomService.java @@ -1,6 +1,6 @@ -package ntou.auction.spring.chat.data.service; +package ntou.auction.spring.chat.service; -import ntou.auction.spring.chat.data.entity.ChatRoom; +import ntou.auction.spring.chat.entity.ChatRoom; import ntou.auction.spring.chat.repository.ChatRoomRepository; import org.springframework.stereotype.Service; diff --git a/src/main/java/ntou/auction/spring/data/Role.java b/src/main/java/ntou/auction/spring/data/Role.java deleted file mode 100644 index 4b6d60b..0000000 --- a/src/main/java/ntou/auction/spring/data/Role.java +++ /dev/null @@ -1,5 +0,0 @@ -package ntou.auction.spring.data; - -public enum Role { - USER, ADMIN -} diff --git a/src/main/java/ntou/auction/spring/mail/EmailService.java b/src/main/java/ntou/auction/spring/mail/EmailService.java index 5ef146d..a807948 100644 --- a/src/main/java/ntou/auction/spring/mail/EmailService.java +++ b/src/main/java/ntou/auction/spring/mail/EmailService.java @@ -2,10 +2,10 @@ import jakarta.mail.Message; import jakarta.mail.internet.InternetAddress; -import ntou.auction.spring.core.AppConfig; -import ntou.auction.spring.data.entity.Product; -import ntou.auction.spring.data.entity.User; -import ntou.auction.spring.data.service.UserService; +import ntou.auction.spring.util.AppConfig; +import ntou.auction.spring.product.entity.Product; +import ntou.auction.spring.account.entity.User; +import ntou.auction.spring.account.service.UserService; import org.springframework.mail.MailException; import org.springframework.mail.javamail.JavaMailSender; import org.springframework.mail.javamail.MimeMessagePreparator; diff --git a/src/main/java/ntou/auction/spring/controller/OrderController.java b/src/main/java/ntou/auction/spring/order/controller/OrderController.java similarity index 94% rename from src/main/java/ntou/auction/spring/controller/OrderController.java rename to src/main/java/ntou/auction/spring/order/controller/OrderController.java index fce9882..06f051f 100644 --- a/src/main/java/ntou/auction/spring/controller/OrderController.java +++ b/src/main/java/ntou/auction/spring/order/controller/OrderController.java @@ -1,8 +1,16 @@ -package ntou.auction.spring.controller; +package ntou.auction.spring.order.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.*; -import ntou.auction.spring.data.service.*; +import ntou.auction.spring.account.response.UserIdentity; +import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.order.entity.Order; +import ntou.auction.spring.order.request.AddOrderRequest; +import ntou.auction.spring.order.request.OperateOrderRequest; +import ntou.auction.spring.order.response.OrderWithProductDetail; +import ntou.auction.spring.order.service.OrderService; +import ntou.auction.spring.product.entity.Product; +import ntou.auction.spring.product.service.ProductService; +import ntou.auction.spring.shoppingcart.service.ShoppingcartService; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; @@ -118,7 +126,7 @@ ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest List> getrequest = request.getProductList(); for (List eachProductAddAmount : getrequest) { - Long productId = eachProductAddAmount.get(0); + Long productId = eachProductAddAmount.getFirst(); Product getProduct = productService.getID(productId); // Id error if (getProduct == null) { diff --git a/src/main/java/ntou/auction/spring/data/entity/Order.java b/src/main/java/ntou/auction/spring/order/entity/Order.java similarity index 90% rename from src/main/java/ntou/auction/spring/data/entity/Order.java rename to src/main/java/ntou/auction/spring/order/entity/Order.java index b293623..3caf4ea 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Order.java +++ b/src/main/java/ntou/auction/spring/order/entity/Order.java @@ -1,12 +1,12 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.order.entity; -import ch.qos.logback.core.joran.sanity.Pair; import com.fasterxml.jackson.annotation.JsonFormat; import jakarta.persistence.*; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; +import ntou.auction.spring.util.AbstractEntity; import java.time.LocalDateTime; import java.util.*; diff --git a/src/main/java/ntou/auction/spring/data/service/OrderRepository.java b/src/main/java/ntou/auction/spring/order/repository/OrderRepository.java similarity index 92% rename from src/main/java/ntou/auction/spring/data/service/OrderRepository.java rename to src/main/java/ntou/auction/spring/order/repository/OrderRepository.java index 09af174..02b0dd9 100644 --- a/src/main/java/ntou/auction/spring/data/service/OrderRepository.java +++ b/src/main/java/ntou/auction/spring/order/repository/OrderRepository.java @@ -1,8 +1,6 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.order.repository; -import jakarta.transaction.Transactional; -import ntou.auction.spring.data.entity.Order; -import ntou.auction.spring.data.entity.Shoppingcart; +import ntou.auction.spring.order.entity.Order; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.data.jpa.repository.Modifying; diff --git a/src/main/java/ntou/auction/spring/data/entity/AddOrderRequest.java b/src/main/java/ntou/auction/spring/order/request/AddOrderRequest.java similarity index 78% rename from src/main/java/ntou/auction/spring/data/entity/AddOrderRequest.java rename to src/main/java/ntou/auction/spring/order/request/AddOrderRequest.java index d0da843..8f6c6e4 100644 --- a/src/main/java/ntou/auction/spring/data/entity/AddOrderRequest.java +++ b/src/main/java/ntou/auction/spring/order/request/AddOrderRequest.java @@ -1,6 +1,5 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.order.request; -import ch.qos.logback.core.joran.sanity.Pair; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; diff --git a/src/main/java/ntou/auction/spring/data/entity/OperateOrderRequest.java b/src/main/java/ntou/auction/spring/order/request/OperateOrderRequest.java similarity index 85% rename from src/main/java/ntou/auction/spring/data/entity/OperateOrderRequest.java rename to src/main/java/ntou/auction/spring/order/request/OperateOrderRequest.java index 2eaf0fb..76a425b 100644 --- a/src/main/java/ntou/auction/spring/data/entity/OperateOrderRequest.java +++ b/src/main/java/ntou/auction/spring/order/request/OperateOrderRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.order.request; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; diff --git a/src/main/java/ntou/auction/spring/data/entity/OrderWithProductDetail.java b/src/main/java/ntou/auction/spring/order/response/OrderWithProductDetail.java similarity index 87% rename from src/main/java/ntou/auction/spring/data/entity/OrderWithProductDetail.java rename to src/main/java/ntou/auction/spring/order/response/OrderWithProductDetail.java index a1f207c..1aa7e49 100644 --- a/src/main/java/ntou/auction/spring/data/entity/OrderWithProductDetail.java +++ b/src/main/java/ntou/auction/spring/order/response/OrderWithProductDetail.java @@ -1,12 +1,12 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.order.response; -import ch.qos.logback.core.joran.sanity.Pair; import com.fasterxml.jackson.annotation.JsonFormat; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; +import ntou.auction.spring.shoppingcart.response.ProductAddAmount; import java.time.LocalDateTime; import java.util.*; diff --git a/src/main/java/ntou/auction/spring/data/service/OrderService.java b/src/main/java/ntou/auction/spring/order/service/OrderService.java similarity index 92% rename from src/main/java/ntou/auction/spring/data/service/OrderService.java rename to src/main/java/ntou/auction/spring/order/service/OrderService.java index 0b606e6..a459b86 100644 --- a/src/main/java/ntou/auction/spring/data/service/OrderService.java +++ b/src/main/java/ntou/auction/spring/order/service/OrderService.java @@ -1,8 +1,11 @@ -package ntou.auction.spring.data.service; - -import ntou.auction.spring.data.entity.Order; -import ntou.auction.spring.data.entity.OrderWithProductDetail; -import ntou.auction.spring.data.entity.ProductAddAmount; +package ntou.auction.spring.order.service; + +import ntou.auction.spring.order.entity.Order; +import ntou.auction.spring.order.response.OrderWithProductDetail; +import ntou.auction.spring.order.repository.OrderRepository; +import ntou.auction.spring.shoppingcart.response.ProductAddAmount; +import ntou.auction.spring.product.service.ProductService; +import ntou.auction.spring.shoppingcart.service.ShoppingcartService; import org.springframework.stereotype.Service; import java.time.Duration; @@ -112,7 +115,7 @@ public void addOrder(Order order) { public boolean checkIsSameSeller(List> list) { Set check = new HashSet<>(); for(List productAddAmount: list) { - check.add(productService.getID(productAddAmount.get(0)).getSellerID()); + check.add(productService.getID(productAddAmount.getFirst()).getSellerID()); } return check.size()==1; } diff --git a/src/main/java/ntou/auction/spring/controller/ProductController.java b/src/main/java/ntou/auction/spring/product/controller/ProductController.java similarity index 97% rename from src/main/java/ntou/auction/spring/controller/ProductController.java rename to src/main/java/ntou/auction/spring/product/controller/ProductController.java index 8f9cc14..7b93a31 100644 --- a/src/main/java/ntou/auction/spring/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/product/controller/ProductController.java @@ -1,11 +1,12 @@ -package ntou.auction.spring.controller; +package ntou.auction.spring.product.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.*; -import ntou.auction.spring.data.service.ProductService; -import ntou.auction.spring.data.service.ShoppingcartService; -import ntou.auction.spring.data.service.UserIdentity; -import ntou.auction.spring.data.service.UserService; +import ntou.auction.spring.product.service.ProductService; +import ntou.auction.spring.shoppingcart.service.ShoppingcartService; +import ntou.auction.spring.account.response.UserIdentity; +import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.product.entity.*; +import ntou.auction.spring.product.request.*; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; diff --git a/src/main/java/ntou/auction/spring/data/entity/Product.java b/src/main/java/ntou/auction/spring/product/entity/Product.java similarity index 95% rename from src/main/java/ntou/auction/spring/data/entity/Product.java rename to src/main/java/ntou/auction/spring/product/entity/Product.java index 7c66363..ac5e7da 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Product.java +++ b/src/main/java/ntou/auction/spring/product/entity/Product.java @@ -1,13 +1,13 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.entity; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; -import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; +import ntou.auction.spring.util.AbstractEntity; import org.hibernate.validator.constraints.Length; import java.time.LocalDateTime; diff --git a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java b/src/main/java/ntou/auction/spring/product/repository/ProductRepository.java similarity index 91% rename from src/main/java/ntou/auction/spring/data/service/ProductRepository.java rename to src/main/java/ntou/auction/spring/product/repository/ProductRepository.java index b9281b5..e7c31ac 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductRepository.java +++ b/src/main/java/ntou/auction/spring/product/repository/ProductRepository.java @@ -1,6 +1,6 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.product.repository; -import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.product.entity.Product; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.data.jpa.repository.Query; diff --git a/src/main/java/ntou/auction/spring/data/entity/BidRequest.java b/src/main/java/ntou/auction/spring/product/request/BidRequest.java similarity index 73% rename from src/main/java/ntou/auction/spring/data/entity/BidRequest.java rename to src/main/java/ntou/auction/spring/product/request/BidRequest.java index 97f9d1c..aea0b4b 100644 --- a/src/main/java/ntou/auction/spring/data/entity/BidRequest.java +++ b/src/main/java/ntou/auction/spring/product/request/BidRequest.java @@ -1,13 +1,10 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.request; -import jakarta.persistence.Column; -import jakarta.persistence.Lob; import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import org.hibernate.validator.constraints.Length; @Data @NoArgsConstructor diff --git a/src/main/java/ntou/auction/spring/data/entity/BuyProductRequest.java b/src/main/java/ntou/auction/spring/product/request/BuyProductRequest.java similarity index 83% rename from src/main/java/ntou/auction/spring/data/entity/BuyProductRequest.java rename to src/main/java/ntou/auction/spring/product/request/BuyProductRequest.java index 31e1a9e..059e62a 100644 --- a/src/main/java/ntou/auction/spring/data/entity/BuyProductRequest.java +++ b/src/main/java/ntou/auction/spring/product/request/BuyProductRequest.java @@ -1,11 +1,10 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.request; import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import org.hibernate.validator.constraints.Length; @Data @NoArgsConstructor diff --git a/src/main/java/ntou/auction/spring/data/entity/PostFixedPriceProductRequest.java b/src/main/java/ntou/auction/spring/product/request/PostFixedPriceProductRequest.java similarity index 96% rename from src/main/java/ntou/auction/spring/data/entity/PostFixedPriceProductRequest.java rename to src/main/java/ntou/auction/spring/product/request/PostFixedPriceProductRequest.java index 214fc50..a48a3c7 100644 --- a/src/main/java/ntou/auction/spring/data/entity/PostFixedPriceProductRequest.java +++ b/src/main/java/ntou/auction/spring/product/request/PostFixedPriceProductRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.request; import jakarta.persistence.Column; import jakarta.persistence.Lob; diff --git a/src/main/java/ntou/auction/spring/data/entity/PostNonFixedPriceProductRequest.java b/src/main/java/ntou/auction/spring/product/request/PostNonFixedPriceProductRequest.java similarity index 96% rename from src/main/java/ntou/auction/spring/data/entity/PostNonFixedPriceProductRequest.java rename to src/main/java/ntou/auction/spring/product/request/PostNonFixedPriceProductRequest.java index 390da51..377b611 100644 --- a/src/main/java/ntou/auction/spring/data/entity/PostNonFixedPriceProductRequest.java +++ b/src/main/java/ntou/auction/spring/product/request/PostNonFixedPriceProductRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.request; import jakarta.persistence.Column; import jakarta.persistence.Lob; diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductRequestGet.java b/src/main/java/ntou/auction/spring/product/request/ProductRequestGet.java similarity index 75% rename from src/main/java/ntou/auction/spring/data/entity/ProductRequestGet.java rename to src/main/java/ntou/auction/spring/product/request/ProductRequestGet.java index 501a6c8..a74b1ee 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductRequestGet.java +++ b/src/main/java/ntou/auction/spring/product/request/ProductRequestGet.java @@ -1,8 +1,5 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.request; -import jakarta.persistence.Column; -import jakarta.persistence.Lob; -import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; diff --git a/src/main/java/ntou/auction/spring/data/entity/UpdateFixedPriceProductRequest.java b/src/main/java/ntou/auction/spring/product/request/UpdateFixedPriceProductRequest.java similarity index 95% rename from src/main/java/ntou/auction/spring/data/entity/UpdateFixedPriceProductRequest.java rename to src/main/java/ntou/auction/spring/product/request/UpdateFixedPriceProductRequest.java index 1a9637f..7fba4ae 100644 --- a/src/main/java/ntou/auction/spring/data/entity/UpdateFixedPriceProductRequest.java +++ b/src/main/java/ntou/auction/spring/product/request/UpdateFixedPriceProductRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.request; import jakarta.persistence.Column; import jakarta.persistence.Lob; diff --git a/src/main/java/ntou/auction/spring/data/entity/UpdateNonFixedPriceProductRequest.java b/src/main/java/ntou/auction/spring/product/request/UpdateNonFixedPriceProductRequest.java similarity index 96% rename from src/main/java/ntou/auction/spring/data/entity/UpdateNonFixedPriceProductRequest.java rename to src/main/java/ntou/auction/spring/product/request/UpdateNonFixedPriceProductRequest.java index b7b3ade..36f27bf 100644 --- a/src/main/java/ntou/auction/spring/data/entity/UpdateNonFixedPriceProductRequest.java +++ b/src/main/java/ntou/auction/spring/product/request/UpdateNonFixedPriceProductRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.product.request; import jakarta.persistence.Column; import jakarta.persistence.Lob; diff --git a/src/main/java/ntou/auction/spring/data/service/ProductService.java b/src/main/java/ntou/auction/spring/product/service/ProductService.java similarity index 94% rename from src/main/java/ntou/auction/spring/data/service/ProductService.java rename to src/main/java/ntou/auction/spring/product/service/ProductService.java index 5de58d6..8f3eaa6 100644 --- a/src/main/java/ntou/auction/spring/data/service/ProductService.java +++ b/src/main/java/ntou/auction/spring/product/service/ProductService.java @@ -1,6 +1,6 @@ -package ntou.auction.spring.data.service; -import jakarta.validation.constraints.Null; -import ntou.auction.spring.data.entity.Product; +package ntou.auction.spring.product.service; +import ntou.auction.spring.product.repository.ProductRepository; +import ntou.auction.spring.product.entity.Product; import org.springframework.stereotype.Service; import java.util.List; diff --git a/src/main/java/ntou/auction/spring/data/service/TimerTask.java b/src/main/java/ntou/auction/spring/product/service/TimerTask.java similarity index 84% rename from src/main/java/ntou/auction/spring/data/service/TimerTask.java rename to src/main/java/ntou/auction/spring/product/service/TimerTask.java index fd307c2..c776882 100644 --- a/src/main/java/ntou/auction/spring/data/service/TimerTask.java +++ b/src/main/java/ntou/auction/spring/product/service/TimerTask.java @@ -1,8 +1,11 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.product.service; +import ntou.auction.spring.shoppingcart.service.ShoppingcartService; +import ntou.auction.spring.account.response.UserIdentity; +import ntou.auction.spring.account.service.UserService; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; -import ntou.auction.spring.data.entity.Product; +import ntou.auction.spring.product.entity.Product; import org.springframework.transaction.annotation.Transactional; import java.util.List; diff --git a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java b/src/main/java/ntou/auction/spring/shoppingcart/controller/ShoppingcartController.java similarity index 89% rename from src/main/java/ntou/auction/spring/controller/ShoppingcartController.java rename to src/main/java/ntou/auction/spring/shoppingcart/controller/ShoppingcartController.java index 72a9d35..3b61154 100644 --- a/src/main/java/ntou/auction/spring/controller/ShoppingcartController.java +++ b/src/main/java/ntou/auction/spring/shoppingcart/controller/ShoppingcartController.java @@ -1,11 +1,16 @@ -package ntou.auction.spring.controller; +package ntou.auction.spring.shoppingcart.controller; import jakarta.validation.Valid; -import ntou.auction.spring.data.entity.*; -import ntou.auction.spring.data.service.ProductService; -import ntou.auction.spring.data.service.ShoppingcartService; -import ntou.auction.spring.data.service.UserIdentity; -import ntou.auction.spring.data.service.UserService; +import ntou.auction.spring.account.entity.User; +import ntou.auction.spring.product.service.ProductService; +import ntou.auction.spring.shoppingcart.service.ShoppingcartService; +import ntou.auction.spring.account.response.UserIdentity; +import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.product.entity.Product; +import ntou.auction.spring.shoppingcart.entity.Shoppingcart; +import ntou.auction.spring.shoppingcart.response.ProductAddAmount; +import ntou.auction.spring.shoppingcart.response.ProductClassificatedBySeller; +import ntou.auction.spring.shoppingcart.request.ShoppingcartRequest; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; diff --git a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java b/src/main/java/ntou/auction/spring/shoppingcart/entity/Shoppingcart.java similarity index 94% rename from src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java rename to src/main/java/ntou/auction/spring/shoppingcart/entity/Shoppingcart.java index 6b61d0d..50d332f 100644 --- a/src/main/java/ntou/auction/spring/data/entity/Shoppingcart.java +++ b/src/main/java/ntou/auction/spring/shoppingcart/entity/Shoppingcart.java @@ -1,10 +1,12 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.shoppingcart.entity; import jakarta.persistence.*; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; +import ntou.auction.spring.util.AbstractEntity; + import java.util.HashMap; import java.util.Map; diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java b/src/main/java/ntou/auction/spring/shoppingcart/repository/ShoppingcartRepository.java similarity index 87% rename from src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java rename to src/main/java/ntou/auction/spring/shoppingcart/repository/ShoppingcartRepository.java index 6620533..f03c37c 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartRepository.java +++ b/src/main/java/ntou/auction/spring/shoppingcart/repository/ShoppingcartRepository.java @@ -1,13 +1,12 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.shoppingcart.repository; import jakarta.transaction.Transactional; -import ntou.auction.spring.data.entity.Shoppingcart; +import ntou.auction.spring.shoppingcart.entity.Shoppingcart; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.data.jpa.repository.Modifying; import org.springframework.data.jpa.repository.Query; -import java.util.ArrayList; import java.util.List; import java.util.Optional; diff --git a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java b/src/main/java/ntou/auction/spring/shoppingcart/request/ShoppingcartRequest.java similarity index 85% rename from src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java rename to src/main/java/ntou/auction/spring/shoppingcart/request/ShoppingcartRequest.java index ce6d3df..eae457e 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ShoppingcartRequest.java +++ b/src/main/java/ntou/auction/spring/shoppingcart/request/ShoppingcartRequest.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.shoppingcart.request; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java b/src/main/java/ntou/auction/spring/shoppingcart/response/ProductAddAmount.java similarity index 68% rename from src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java rename to src/main/java/ntou/auction/spring/shoppingcart/response/ProductAddAmount.java index 4366945..e358e97 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductAddAmount.java +++ b/src/main/java/ntou/auction/spring/shoppingcart/response/ProductAddAmount.java @@ -1,8 +1,10 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.shoppingcart.response; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; +import ntou.auction.spring.product.entity.Product; + @Getter @NoArgsConstructor @AllArgsConstructor diff --git a/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java b/src/main/java/ntou/auction/spring/shoppingcart/response/ProductClassificatedBySeller.java similarity index 87% rename from src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java rename to src/main/java/ntou/auction/spring/shoppingcart/response/ProductClassificatedBySeller.java index 06bf779..d9b2e55 100644 --- a/src/main/java/ntou/auction/spring/data/entity/ProductClassificatedBySeller.java +++ b/src/main/java/ntou/auction/spring/shoppingcart/response/ProductClassificatedBySeller.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.shoppingcart.response; import lombok.AllArgsConstructor; import lombok.Getter; diff --git a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java b/src/main/java/ntou/auction/spring/shoppingcart/service/ShoppingcartService.java similarity index 92% rename from src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java rename to src/main/java/ntou/auction/spring/shoppingcart/service/ShoppingcartService.java index 1653e57..6394c86 100644 --- a/src/main/java/ntou/auction/spring/data/service/ShoppingcartService.java +++ b/src/main/java/ntou/auction/spring/shoppingcart/service/ShoppingcartService.java @@ -1,7 +1,9 @@ -package ntou.auction.spring.data.service; +package ntou.auction.spring.shoppingcart.service; -import ntou.auction.spring.data.entity.Product; -import ntou.auction.spring.data.entity.Shoppingcart; +import ntou.auction.spring.product.entity.Product; +import ntou.auction.spring.shoppingcart.entity.Shoppingcart; +import ntou.auction.spring.product.service.ProductService; +import ntou.auction.spring.shoppingcart.repository.ShoppingcartRepository; import org.springframework.stereotype.Service; import java.util.*; @@ -95,7 +97,7 @@ public Long checkIsProductAllInShoppingCart(List> order, Long userid) public boolean checkIsViolateSelfBuying(List> order, Long userid) { for(List product: order) { - Product nowProduct = productService.getID(product.get(0)); + Product nowProduct = productService.getID(product.getFirst()); if(nowProduct.getSellerID().equals(userid)) return true; } return false; diff --git a/src/main/java/ntou/auction/spring/data/entity/AbstractEntity.java b/src/main/java/ntou/auction/spring/util/AbstractEntity.java similarity index 96% rename from src/main/java/ntou/auction/spring/data/entity/AbstractEntity.java rename to src/main/java/ntou/auction/spring/util/AbstractEntity.java index ffd93c8..115a47c 100644 --- a/src/main/java/ntou/auction/spring/data/entity/AbstractEntity.java +++ b/src/main/java/ntou/auction/spring/util/AbstractEntity.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.data.entity; +package ntou.auction.spring.util; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; diff --git a/src/main/java/ntou/auction/spring/core/AppConfig.java b/src/main/java/ntou/auction/spring/util/AppConfig.java similarity index 96% rename from src/main/java/ntou/auction/spring/core/AppConfig.java rename to src/main/java/ntou/auction/spring/util/AppConfig.java index 38bd0b1..9998a2c 100644 --- a/src/main/java/ntou/auction/spring/core/AppConfig.java +++ b/src/main/java/ntou/auction/spring/util/AppConfig.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.core; +package ntou.auction.spring.util; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; diff --git a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java b/src/main/java/ntou/auction/spring/util/RestResponseEntityExceptionHandler.java similarity index 96% rename from src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java rename to src/main/java/ntou/auction/spring/util/RestResponseEntityExceptionHandler.java index 4f9ebea..b5ea398 100644 --- a/src/main/java/ntou/auction/spring/controller/RestResponseEntityExceptionHandler.java +++ b/src/main/java/ntou/auction/spring/util/RestResponseEntityExceptionHandler.java @@ -1,4 +1,4 @@ -package ntou.auction.spring.controller; +package ntou.auction.spring.util; import jakarta.validation.ConstraintViolation; import jakarta.validation.ConstraintViolationException; @@ -15,7 +15,6 @@ import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ResponseStatus; import org.springframework.web.context.request.WebRequest; -import org.springframework.web.servlet.NoHandlerFoundException; import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; import java.util.*; From 713df3d8a30b9003560835075484d66eae2b044f Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 01:40:54 +0800 Subject: [PATCH 156/163] Create codeql.yml --- .github/workflows/codeql.yml | 87 ++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 .github/workflows/codeql.yml diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml new file mode 100644 index 0000000..0da67df --- /dev/null +++ b/.github/workflows/codeql.yml @@ -0,0 +1,87 @@ +# For most projects, this workflow file will not need changing; you simply need +# to commit it to your repository. +# +# You may wish to alter this file to override the set of languages analyzed, +# or to provide custom queries or build logic. +# +# ******** NOTE ******** +# We have attempted to detect the languages in your repository. Please check +# the `language` matrix defined below to confirm you have the correct set of +# supported CodeQL languages. +# +name: "CodeQL" + +on: + push: + branches: [ "main", "development", "feature/*" ] + pull_request: + branches: [ "main", "development", "feature/*" ] + schedule: + - cron: '40 16 * * 4' + +jobs: + analyze: + name: Analyze + # Runner size impacts CodeQL analysis time. To learn more, please see: + # - https://gh.io/recommended-hardware-resources-for-running-codeql + # - https://gh.io/supported-runners-and-hardware-resources + # - https://gh.io/using-larger-runners + # Consider using larger runners for possible analysis time improvements. + runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }} + timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }} + permissions: + actions: read + contents: read + security-events: write + + strategy: + fail-fast: false + matrix: + language: [ 'java-kotlin' ] + # CodeQL supports [ 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift' ] + # Use only 'java-kotlin' to analyze code written in Java, Kotlin or both + # Use only 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both + # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Set up Java + uses: actions/setup-java@v3 + with: + distribution: liberica + java-version: 21 + + # Initializes the CodeQL tools for scanning. + - name: Initialize CodeQL + uses: github/codeql-action/init@v3 + with: + languages: ${{ matrix.language }} + # If you wish to specify custom queries, you can do so here or in a config file. + # By default, queries listed here will override any specified in a config file. + # Prefix the list here with "+" to use these queries and those in the config file. + + # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs + # queries: security-extended,security-and-quality + + + # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift). + # If this step fails, then you should remove it and run the build manually (see below) + - name: Autobuild + uses: github/codeql-action/autobuild@v3 + + # ℹ️ Command-line programs to run using the OS shell. + # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun + + # If the Autobuild fails above, remove it and uncomment the following three lines. + # modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance. + + # - run: | + # echo "Run, Build Application using script" + # ./location_of_script_within_repo/buildscript.sh + + - name: Perform CodeQL Analysis + uses: github/codeql-action/analyze@v3 + with: + category: "/language:${{matrix.language}}" From 4f8fa6ce07f69eb951f3e149bc0a4179921abd9b Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 01:53:11 +0800 Subject: [PATCH 157/163] Delete .github/workflows/codecov.yml --- .github/workflows/codecov.yml | 30 ------------------------------ 1 file changed, 30 deletions(-) delete mode 100644 .github/workflows/codecov.yml diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml deleted file mode 100644 index b7fc200..0000000 --- a/.github/workflows/codecov.yml +++ /dev/null @@ -1,30 +0,0 @@ -name: Workflow for Codecov java maven -on: [push, pull_request] -env: - NA_DB_URL: 'jdbc:mariadb://localhost:3306/NA' - NA_DB_USER: 'NA' - NA_DB_PASSWORD: 'NA' -jobs: - run: - runs-on: ubuntu-latest - steps: - - name: Checkout - uses: actions/checkout@v4 - - name: Set up JDK 21 - uses: actions/setup-java@v1 - with: - java-version: 21 - - name: Start MariaDB - uses: getong/mariadb-action@v1.1 - with: - mysql database: 'NA' - mysql user: 'NA' - mysql password: 'NA' - - name: Install dependencies - run: mvn install -DskipTests=true -Dmaven.javadoc.skip=true -B -V - - name: Run tests and collect coverage - run: mvn -B test - - name: Upload coverage to Codecov - uses: codecov/codecov-action@v4-beta - env: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} From 2c19e16644c19d1a5998c9b0f1c36a94b77782ae Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 13:49:33 +0800 Subject: [PATCH 158/163] Update docker.yml --- .github/workflows/docker.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml index afa81e1..4a16b68 100644 --- a/.github/workflows/docker.yml +++ b/.github/workflows/docker.yml @@ -4,6 +4,7 @@ on: push: branches: - 'development' + - 'main' env: NA_DB_URL: 'jdbc:mariadb://localhost:3306/NA' NA_DB_USER: 'NA' From 540128da865f9faead9f03a0e2fc1541cbca36ce Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 14:17:17 +0800 Subject: [PATCH 159/163] refactor: remove unused test code. --- .../spring/NtouAuctionJavaApplicationTests.java | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 src/test/java/ntou/auction/spring/NtouAuctionJavaApplicationTests.java diff --git a/src/test/java/ntou/auction/spring/NtouAuctionJavaApplicationTests.java b/src/test/java/ntou/auction/spring/NtouAuctionJavaApplicationTests.java deleted file mode 100644 index d6b285b..0000000 --- a/src/test/java/ntou/auction/spring/NtouAuctionJavaApplicationTests.java +++ /dev/null @@ -1,13 +0,0 @@ -package ntou.auction.spring; - -import org.junit.jupiter.api.Test; -import org.springframework.boot.test.context.SpringBootTest; - -@SpringBootTest -class NtouAuctionJavaApplicationTests { - - @Test - void contextLoads() { - } - -} From e69626cb162943d06e9d3daca6f41145129dfa93 Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 15:35:46 +0800 Subject: [PATCH 160/163] feat: Introduce Email Notification functionality. --- .../auction/spring/mail/EmailService.java | 129 +++++++++++++++++- .../order/controller/OrderController.java | 17 ++- .../spring/order/service/OrderService.java | 7 +- .../product/controller/ProductController.java | 97 +++++++------ .../spring/product/service/TimerTask.java | 22 +-- 5 files changed, 203 insertions(+), 69 deletions(-) diff --git a/src/main/java/ntou/auction/spring/mail/EmailService.java b/src/main/java/ntou/auction/spring/mail/EmailService.java index a807948..afa1752 100644 --- a/src/main/java/ntou/auction/spring/mail/EmailService.java +++ b/src/main/java/ntou/auction/spring/mail/EmailService.java @@ -2,10 +2,11 @@ import jakarta.mail.Message; import jakarta.mail.internet.InternetAddress; -import ntou.auction.spring.util.AppConfig; -import ntou.auction.spring.product.entity.Product; import ntou.auction.spring.account.entity.User; import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.order.entity.Order; +import ntou.auction.spring.product.entity.Product; +import ntou.auction.spring.util.AppConfig; import org.springframework.mail.MailException; import org.springframework.mail.javamail.JavaMailSender; import org.springframework.mail.javamail.MimeMessagePreparator; @@ -25,7 +26,7 @@ public EmailService(JavaMailSender mailSender, UserService userService, AppConfi this.appConfig = appConfig; } - public void sendMailBid(Long userId, Product product) { + public void sendMailBidSuccess(Long userId, Product product) { if (userService.get(userId).isEmpty()) { System.err.println("找不到ID為 " + userId + " 的使用者，無法寄出得標成功通知"); @@ -56,4 +57,126 @@ public void sendMailBid(Long userId, Product product) { } } + /* + public void sendMailBidFailed(Long userId, Product product) { + + if (userService.get(userId).isEmpty()) { + System.err.println("找不到ID為 " + userId + " 的使用者，無法寄出商品下架通知"); + return; + } + User customer = userService.get(userId).get(); + + MimeMessagePreparator preparator = mimeMessage -> { + mimeMessage.setSubject("[NTOU Auction] 商品下架通知", "UTF-8"); + mimeMessage.setRecipient(Message.RecipientType.TO, + new InternetAddress(customer.getEmail())); + mimeMessage.setFrom(new InternetAddress(appConfig.getMailUsername())); + mimeMessage.setText("親愛的 " + customer.getName() + + " (@" + customer.getUsername() + ") 您好:" + "\n" + + "您之前參加競標的 " + product.getProductName() + " 商品" + + "目前已由賣家下架，造成您的不便還請見諒。" + "\n\n" + + "感謝您使用 NTOU Auction，歡迎選購其他商品！" + "\n\n" + + "此為系統自動發送之郵件，請勿回覆!", "UTF-8" + + ); + mimeMessage.setSentDate(new Date()); + }; + + try { + this.mailSender.send(preparator); + } catch (MailException ex) { + System.err.println(ex.getMessage()); + } + } + */ + public void sendMailOrderEstablished(Long userId, Order order) { + + if (userService.get(userId).isEmpty() || userService.get(order.getSellerid()).isEmpty()) { + System.err.println("找不到ID為 " + userId + " 的使用者，或查無賣家，無法寄出訂單成立通知"); + return; + } + User customer = userService.get(userId).get(); + User seller = userService.get(order.getSellerid()).get(); + + MimeMessagePreparator buyerPreparator = mimeMessage -> { + mimeMessage.setSubject("[NTOU Auction] 訂單成立通知", "UTF-8"); + mimeMessage.setRecipient(Message.RecipientType.TO, + new InternetAddress(customer.getEmail())); + mimeMessage.setFrom(new InternetAddress(appConfig.getMailUsername())); + mimeMessage.setText("親愛的 " + customer.getName() + + " (@" + customer.getUsername() + ") 您好:" + "\n" + + "您已成功購買賣家為 @" + seller.getUsername() + " 的商品，" + + "您這次購買了 " + order.getProductAddAmountList().size() + " 個品項的商品" + "\n" + + "目前訂單狀態為等待賣家確認，訂單詳細資訊請上NTOU Auction確認。" + "\n\n" + + "感謝您使用 NTOU Auction，祝您購物愉快！" + "\n\n" + + "此為系統自動發送之郵件，請勿回覆!", "UTF-8" + + ); + mimeMessage.setSentDate(new Date()); + }; + + MimeMessagePreparator sellerPreparator = mimeMessage -> { + mimeMessage.setSubject("[NTOU Auction] 訂單成立通知", "UTF-8"); + mimeMessage.setRecipient(Message.RecipientType.TO, + new InternetAddress(seller.getEmail())); + mimeMessage.setFrom(new InternetAddress(appConfig.getMailUsername())); + mimeMessage.setText("親愛的 " + seller.getName() + + " (@" + seller.getUsername() + ") 您好:" + "\n" + + "買家 @" + customer.getUsername() + " 已下訂您的商品，" + + "目前訂單狀態為等待確認，請您盡快上NTOU Auction更新訂單狀態。" + "\n\n" + + "感謝您使用 NTOU Auction，祝您交易愉快！" + "\n\n" + + "此為系統自動發送之郵件，請勿回覆!", "UTF-8" + + ); + mimeMessage.setSentDate(new Date()); + }; + + try { + this.mailSender.send(buyerPreparator); + this.mailSender.send(sellerPreparator); + } catch (MailException ex) { + System.err.println(ex.getMessage()); + } + } + + public void sendMailOrderUpdate(Long userId, Order order) { + + if (userService.get(userId).isEmpty() || userService.get(order.getSellerid()).isEmpty()) { + System.err.println("找不到ID為 " + userId + " 的使用者，或查無賣家，無法寄出訂單狀態更新通知"); + return; + } + User customer = userService.get(userId).get(); + User seller = userService.get(order.getSellerid()).get(); + String status; + if (order.getStatus() == 0L) { + status = "賣家拒絕您的訂單"; + } else if (order.getStatus() == 2L) { + status = "賣家同意您的訂單"; + } else { + status = "未知"; + } + + MimeMessagePreparator buyerPreparator = mimeMessage -> { + mimeMessage.setSubject("[NTOU Auction] 訂單狀態更新通知", "UTF-8"); + mimeMessage.setRecipient(Message.RecipientType.TO, + new InternetAddress(customer.getEmail())); + mimeMessage.setFrom(new InternetAddress(appConfig.getMailUsername())); + mimeMessage.setText("親愛的 " + customer.getName() + + " (@" + customer.getUsername() + ") 您好:" + "\n" + + "您之前購買賣家為 @" + seller.getUsername() + " 的商品，" + + "目前訂單狀態為 " + status + " ，訂單詳細資訊請上NTOU Auction確認。" + "\n\n" + + "感謝您使用 NTOU Auction，祝您購物愉快！" + "\n\n" + + "此為系統自動發送之郵件，請勿回覆!", "UTF-8" + + ); + mimeMessage.setSentDate(new Date()); + }; + + try { + this.mailSender.send(buyerPreparator); + } catch (MailException ex) { + System.err.println(ex.getMessage()); + } + } + } diff --git a/src/main/java/ntou/auction/spring/order/controller/OrderController.java b/src/main/java/ntou/auction/spring/order/controller/OrderController.java index 06f051f..afe469c 100644 --- a/src/main/java/ntou/auction/spring/order/controller/OrderController.java +++ b/src/main/java/ntou/auction/spring/order/controller/OrderController.java @@ -3,6 +3,7 @@ import jakarta.validation.Valid; import ntou.auction.spring.account.response.UserIdentity; import ntou.auction.spring.account.service.UserService; +import ntou.auction.spring.mail.EmailService; import ntou.auction.spring.order.entity.Order; import ntou.auction.spring.order.request.AddOrderRequest; import ntou.auction.spring.order.request.OperateOrderRequest; @@ -28,7 +29,7 @@ public class OrderController { private final ShoppingcartService shoppingcartService; private final UserService userService; - + private final EmailService emailService; private final UserIdentity userIdentity; private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); @@ -49,11 +50,12 @@ public class OrderController { private static final Map selfBuyingError = Collections.singletonMap("message", "不可以購買自己的商品"); - public OrderController(OrderService orderService, ProductService productService, ShoppingcartService shoppingcartService, UserService userService, UserIdentity userIdentity) { + public OrderController(OrderService orderService, ProductService productService, ShoppingcartService shoppingcartService, UserService userService, EmailService emailService, UserIdentity userIdentity) { this.orderService = orderService; this.productService = productService; this.shoppingcartService = shoppingcartService; this.userService = userService; + this.emailService = emailService; this.userIdentity = userIdentity; } @@ -137,8 +139,8 @@ ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest // checkInShoppingCart -> -1: format error, 0: false, 1: true Long checkInShoppingCart = shoppingcartService.checkIsProductAllInShoppingCart(getrequest, userId); - if(checkInShoppingCart.equals(-1L)) return ResponseEntity.badRequest().body(formatError); - if(checkInShoppingCart.equals(0L)) return ResponseEntity.badRequest().body(notFoundInShoppingCartError); + if (checkInShoppingCart.equals(-1L)) return ResponseEntity.badRequest().body(formatError); + if (checkInShoppingCart.equals(0L)) return ResponseEntity.badRequest().body(notFoundInShoppingCartError); for (List eachProductAddAmount : getrequest) { Long productId = eachProductAddAmount.get(0); @@ -153,11 +155,11 @@ ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest // Same seller boolean checkSameSeller = orderService.checkIsSameSeller(getrequest); - if(!checkSameSeller) return ResponseEntity.badRequest().body(tooManySellerMessage); + if (!checkSameSeller) return ResponseEntity.badRequest().body(tooManySellerMessage); // Self buying boolean checkSelfBuying = shoppingcartService.checkIsViolateSelfBuying(getrequest, userId); - if(checkSelfBuying) return ResponseEntity.badRequest().body(selfBuyingError); + if (checkSelfBuying) return ResponseEntity.badRequest().body(selfBuyingError); // order status -> 0: reject, 1: waiting for submit, 2: submitted but not paid, 3: order done Order order = new Order(); @@ -186,6 +188,7 @@ ResponseEntity> addOrder(@Valid @RequestBody AddOrderRequest shoppingcartService.decreaseProductByUserId(userId, productId, amount); } orderService.addOrder(order); + emailService.sendMailOrderEstablished(order.getBuyerid(),order); return ResponseEntity.ok(successMessage); } @@ -244,7 +247,7 @@ ResponseEntity> makeCancel(@Valid @RequestBody OperateOrderR if (result.equals(-1L)) return ResponseEntity.badRequest().body(expiredError); Order thisOrder = orderService.findOrderById(orderId); boolean check = orderService.addAmountToProduct(thisOrder); - if(!check) return ResponseEntity.badRequest().body(orderNotFound); // this may not be happened + if (!check) return ResponseEntity.badRequest().body(orderNotFound); // this may not be happened return ResponseEntity.ok(successMessage); } } diff --git a/src/main/java/ntou/auction/spring/order/service/OrderService.java b/src/main/java/ntou/auction/spring/order/service/OrderService.java index a459b86..0584e4a 100644 --- a/src/main/java/ntou/auction/spring/order/service/OrderService.java +++ b/src/main/java/ntou/auction/spring/order/service/OrderService.java @@ -1,5 +1,6 @@ package ntou.auction.spring.order.service; +import ntou.auction.spring.mail.EmailService; import ntou.auction.spring.order.entity.Order; import ntou.auction.spring.order.response.OrderWithProductDetail; import ntou.auction.spring.order.repository.OrderRepository; @@ -20,13 +21,15 @@ public class OrderService { private final ProductService productService; private final ShoppingcartService shoppingcartService; + private final EmailService emailService; private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); - public OrderService(OrderRepository repository, ProductService productService, ShoppingcartService shoppingcartService) { + public OrderService(OrderRepository repository, ProductService productService, ShoppingcartService shoppingcartService, EmailService emailService) { this.repository = repository; this.productService = productService; this.shoppingcartService = shoppingcartService; + this.emailService = emailService; } public Order findOrderById(Long Id) { return repository.findById(Id).orElse(null); @@ -68,6 +71,7 @@ public Long submitOrder(Long orderId, Long userId) { if(!Objects.equals(findOrderById(orderId).getSellerid(), userId)) return 2L; getorder.setStatus(2L); repository.save(getorder); + emailService.sendMailOrderUpdate(getorder.getBuyerid(),getorder); return 3L; } @@ -80,6 +84,7 @@ public Long rejectOrder(Long orderId, Long userId) { if(!Objects.equals(findOrderById(orderId).getSellerid(), userId)) return 2L; getorder.setStatus(0L); repository.save(getorder); + emailService.sendMailOrderUpdate(getorder.getBuyerid(),getorder); return 3L; } diff --git a/src/main/java/ntou/auction/spring/product/controller/ProductController.java b/src/main/java/ntou/auction/spring/product/controller/ProductController.java index 7b93a31..b79fe13 100644 --- a/src/main/java/ntou/auction/spring/product/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/product/controller/ProductController.java @@ -28,7 +28,6 @@ public class ProductController { private final UserService userService; private final ShoppingcartService shoppingcartService; - public ProductController(ProductService productService, UserIdentity userIdentity, UserService userService, ShoppingcartService shoppingcartService) { this.productService = productService; this.userIdentity = userIdentity; @@ -39,13 +38,13 @@ public ProductController(ProductService productService, UserIdentity userIdentit @GetMapping("/product/name/{name}") @ResponseBody - public ListgetProductName(@PathVariable String name ) { - return productService.findByProductName(name); + public List getProductName(@PathVariable String name) { + return productService.findByProductName(name); } @GetMapping("/product/classification/{classification}") @ResponseBody - public ListgetProductClassification(@PathVariable String classification) { + public List getProductClassification(@PathVariable String classification) { return productService.findByProductClassification(classification); } @@ -62,9 +61,9 @@ Product getProduct(@PathVariable long ID) { } @PostMapping("/fixedproduct") - ResponseEntity> postProduct(@Valid @RequestBody PostFixedPriceProductRequest request){ //productrequest的限制 + ResponseEntity> postProduct(@Valid @RequestBody PostFixedPriceProductRequest request) { //productrequest的限制 - Map successMessage = Collections.singletonMap("message","成功上架"); + Map successMessage = Collections.singletonMap("message", "成功上架"); Product product = new Product(); @@ -91,10 +90,10 @@ ResponseEntity> postProduct(@Valid @RequestBody PostFixedPric } @PostMapping("/nonfixedproduct") - ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedPriceProductRequest request){ //productrequest的限制 + ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedPriceProductRequest request) { //productrequest的限制 - Map successMessage = Collections.singletonMap("message","成功上架"); - Map fail = Collections.singletonMap("message","截止時間錯誤"); + Map successMessage = Collections.singletonMap("message", "成功上架"); + Map fail = Collections.singletonMap("message", "截止時間錯誤"); Product product = new Product(); @@ -119,7 +118,7 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedP DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); LocalDateTime dateTime = LocalDateTime.parse(request.getFinishTime(), formatter); - if(!now.isBefore(dateTime)){ + if (!now.isBefore(dateTime)) { return ResponseEntity.badRequest().body(fail); } product.setFinishTime(dateTime); @@ -128,45 +127,45 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixedP return ResponseEntity.ok(successMessage); } - @PatchMapping("/bid") //商品ID 出價。出價也需傳入token - ResponseEntity> bidProduct(@Valid @RequestBody BidRequest request){ + @PatchMapping("/bid") + //商品ID 出價。出價也需傳入token + ResponseEntity> bidProduct(@Valid @RequestBody BidRequest request) { - Map successMessage = Collections.singletonMap("message","成功出價"); - Map failMessage = Collections.singletonMap("message","出價不合理，出價需比當前最高價高" + productService.getID(request.getProductID()).getBidIncrement()); - Map expired = Collections.singletonMap("message","競標已結束"); + Map successMessage = Collections.singletonMap("message", "成功出價"); + Map failMessage = Collections.singletonMap("message", "出價不合理，出價需比當前最高價高" + productService.getID(request.getProductID()).getBidIncrement()); + Map expired = Collections.singletonMap("message", "競標已結束"); LocalDateTime now = LocalDateTime.now(); - if(!now.isBefore(productService.getID(request.getProductID()).getFinishTime())){ + if (!now.isBefore(productService.getID(request.getProductID()).getFinishTime())) { return ResponseEntity.badRequest().body(expired); } - if(!productService.isBidReasonable(request.getBid(), request.getProductID())) { + if (!productService.isBidReasonable(request.getBid(), request.getProductID())) { return ResponseEntity.badRequest().body(failMessage); } System.out.println(userIdentity.getUsername()); - productService.bid(request.getBid(), request.getProductID(),userService.findByUsername(userIdentity.getUsername()).getId()); + productService.bid(request.getBid(), request.getProductID(), userService.findByUsername(userIdentity.getUsername()).getId()); return ResponseEntity.ok(successMessage); } - @PostMapping("/buy") - ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequest request){ + ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequest request) { - Map successMessage = Collections.singletonMap("message","成功加入購物車"); - Map notEnoughMessage = Collections.singletonMap("message","商品剩餘數量不足"); - Map errorMessage = Collections.singletonMap("message","只能將不二價商品加入購物車"); + Map successMessage = Collections.singletonMap("message", "成功加入購物車"); + Map notEnoughMessage = Collections.singletonMap("message", "商品剩餘數量不足"); + Map errorMessage = Collections.singletonMap("message", "只能將不二價商品加入購物車"); Map productNotExistMessage = Collections.singletonMap("message", "商品不存在或無法購買"); // 商品是否存在 - if( productService.getID(request.getProductID())==null){ + if (productService.getID(request.getProductID()) == null) { return ResponseEntity.badRequest().body(productNotExistMessage); } // 購物車是空的 // 只檢查request送來的加入數量 - if (shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId())==null){ + if (shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId()) == null) { if (request.getProductAmount() > productService.getID(request.getProductID()).getProductAmount()) { return ResponseEntity.badRequest().body(notEnoughMessage); } else { @@ -176,7 +175,7 @@ ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequ } // 購物車裡面還沒有要加入的商品 // 只檢查request送來的加入數量 - if(shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId()).getProductItems().get(request.getProductID())==null){ + if (shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId()).getProductItems().get(request.getProductID()) == null) { if (request.getProductAmount() > productService.getID(request.getProductID()).getProductAmount()) { return ResponseEntity.badRequest().body(notEnoughMessage); } else { @@ -190,7 +189,7 @@ ResponseEntity> buyProduct(@Valid @RequestBody BuyProductRequ if (request.getProductAmount() + shoppingcartService.getByUserId(userService.findByUsername(userIdentity.getUsername()).getId()).getProductItems().get(request.getProductID()) > productService.getID(request.getProductID()).getProductAmount()) { //要買的數量 > 商品剩餘數量 return ResponseEntity.badRequest().body(notEnoughMessage); } - if(!productService.getID(request.getProductID()).getIsFixedPrice()){ + if (!productService.getID(request.getProductID()).getIsFixedPrice()) { return ResponseEntity.badRequest().body(errorMessage); } //public void addProductByUserId(Long userId, Long productId, Long amount) { @@ -205,13 +204,13 @@ List getProductInSellerCenter() { } @DeleteMapping("/{ID}") - ResponseEntity> deleteProduct(@PathVariable long ID){ - Map successMessage = Collections.singletonMap("message","成功刪除"); - Map failMessage = Collections.singletonMap("message","刪錯商品嚕"); + ResponseEntity> deleteProduct(@PathVariable long ID) { + Map successMessage = Collections.singletonMap("message", "成功刪除"); + Map failMessage = Collections.singletonMap("message", "刪錯商品嚕"); Product p = productService.getID(ID); - if(!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), p.getSellerID())){ + if (!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), p.getSellerID())) { return ResponseEntity.badRequest().body(failMessage); } p.setProductAmount(0L); @@ -222,13 +221,13 @@ ResponseEntity> deleteProduct(@PathVariable long ID){ } @PutMapping("/fixedproduct/{ID}") - ResponseEntity> putFixedProduct(@PathVariable long ID , @Valid @RequestBody UpdateFixedPriceProductRequest request){ + ResponseEntity> putFixedProduct(@PathVariable long ID, @Valid @RequestBody UpdateFixedPriceProductRequest request) { - Map successMessage = Collections.singletonMap("message","成功更新不二價商品"); - Map failMessage = Collections.singletonMap("message","更新錯商品嚕"); + Map successMessage = Collections.singletonMap("message", "成功更新不二價商品"); + Map failMessage = Collections.singletonMap("message", "更新錯商品嚕"); Product product = productService.getID(ID); - if(!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), product.getSellerID())){ + if (!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), product.getSellerID())) { return ResponseEntity.badRequest().body(failMessage); } product.setProductName(request.getProductName()); @@ -243,17 +242,17 @@ ResponseEntity> putFixedProduct(@PathVariable long ID , @Vali } @PutMapping("/nonfixedproduct/{ID}") - ResponseEntity> putNonFixedProduct(@PathVariable long ID , @Valid @RequestBody UpdateNonFixedPriceProductRequest request){ - - Map successMessage = Collections.singletonMap("message","成功更新競標商品"); - Map failToPostponeAuction = Collections.singletonMap("message","延長競標截止時間失敗，因為有人得標嚕"); - Map fail = Collections.singletonMap("message","截止時間錯誤"); - Map failToSetUpsetPrice = Collections.singletonMap("message","底價不得更改，因為有人出價了"); - Map failToSetBidIncrement = Collections.singletonMap("message","每次增加金額不得更改，因為有人出價了"); - Map failMessage = Collections.singletonMap("message","更新錯商品嚕阿"); + ResponseEntity> putNonFixedProduct(@PathVariable long ID, @Valid @RequestBody UpdateNonFixedPriceProductRequest request) { + + Map successMessage = Collections.singletonMap("message", "成功更新競標商品"); + Map failToPostponeAuction = Collections.singletonMap("message", "延長競標截止時間失敗，因為有人得標嚕"); + Map fail = Collections.singletonMap("message", "截止時間錯誤"); + Map failToSetUpsetPrice = Collections.singletonMap("message", "底價不得更改，因為有人出價了"); + Map failToSetBidIncrement = Collections.singletonMap("message", "每次增加金額不得更改，因為有人出價了"); + Map failMessage = Collections.singletonMap("message", "更新錯商品嚕阿"); Product product = productService.getID(ID); - if(!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), product.getSellerID())){ + if (!Objects.equals(userService.findByUsername(userIdentity.getUsername()).getId(), product.getSellerID())) { return ResponseEntity.badRequest().body(failMessage); } product.setProductName(request.getProductName()); @@ -262,13 +261,13 @@ ResponseEntity> putNonFixedProduct(@PathVariable long ID , @V product.setProductType(request.getProductType()); - Map productMap= product.getBidInfo(); - if(!productMap.isEmpty() && !Objects.equals(request.getUpsetPrice(), product.getUpsetPrice())){ //map不為空，有人出價過了。且更改的底價 != 原本底價 + Map productMap = product.getBidInfo(); + if (!productMap.isEmpty() && !Objects.equals(request.getUpsetPrice(), product.getUpsetPrice())) { //map不為空，有人出價過了。且更改的底價 != 原本底價 return ResponseEntity.badRequest().body(failToSetUpsetPrice); } product.setUpsetPrice(request.getUpsetPrice()); - if(!productMap.isEmpty() && !Objects.equals(request.getBidIncrement(), product.getBidIncrement())){ //map不為空，有人出價過了。且被更改每口叫價 + if (!productMap.isEmpty() && !Objects.equals(request.getBidIncrement(), product.getBidIncrement())) { //map不為空，有人出價過了。且被更改每口叫價 return ResponseEntity.badRequest().body(failToSetBidIncrement); } product.setBidIncrement(request.getBidIncrement()); @@ -276,10 +275,10 @@ ResponseEntity> putNonFixedProduct(@PathVariable long ID , @V LocalDateTime now = LocalDateTime.now(); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); LocalDateTime dateTime = LocalDateTime.parse(request.getFinishTime(), formatter); - if(!now.isBefore(dateTime)){ + if (!now.isBefore(dateTime)) { return ResponseEntity.badRequest().body(fail); } - if(product.getIsAuction()) { //代表競標結束且有被加入購物車 + if (product.getIsAuction()) { //代表競標結束且有被加入購物車 return ResponseEntity.badRequest().body(failToPostponeAuction); } diff --git a/src/main/java/ntou/auction/spring/product/service/TimerTask.java b/src/main/java/ntou/auction/spring/product/service/TimerTask.java index c776882..1d739c5 100644 --- a/src/main/java/ntou/auction/spring/product/service/TimerTask.java +++ b/src/main/java/ntou/auction/spring/product/service/TimerTask.java @@ -1,8 +1,7 @@ package ntou.auction.spring.product.service; +import ntou.auction.spring.mail.EmailService; import ntou.auction.spring.shoppingcart.service.ShoppingcartService; -import ntou.auction.spring.account.response.UserIdentity; -import ntou.auction.spring.account.service.UserService; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import ntou.auction.spring.product.entity.Product; @@ -11,33 +10,38 @@ import java.util.List; import java.util.Map; import java.util.Optional; + @Component public class TimerTask { - private final ProductService productService; + private final ProductService productService; private final ShoppingcartService shoppingcartService; + private final EmailService emailService; - public TimerTask(ProductService productService, ShoppingcartService shoppingcartService, UserIdentity userIdentity, UserService userService) { + public TimerTask(ProductService productService, ShoppingcartService shoppingcartService, EmailService emailService) { this.productService = productService; this.shoppingcartService = shoppingcartService; + this.emailService = emailService; } + @Transactional @Scheduled(cron = "0 * * * * ?") //每分鐘的第0秒 public void execute() { - List productList = productService.findByProductNonFixed(); + List productList = productService.findByProductNonFixed(); for (Product product : productList) { System.out.println(product.getId()); if (product.isExpired()) { //競標結束 - Map productMap= product.getBidInfo(); + Map productMap = product.getBidInfo(); - Optional> max0 = productMap.entrySet() + Optional> max0 = productMap.entrySet() .stream().max(Map.Entry.comparingByValue()); - if(max0.isPresent()) { - shoppingcartService.addProductByUserId(max0.get().getKey(),product.getId(),1L); + if (max0.isPresent()) { + shoppingcartService.addProductByUserId(max0.get().getKey(), product.getId(), 1L); product.setIsAuction(true); productService.store(product); + emailService.sendMailBidSuccess(max0.get().getKey(), product); } } } From 1c41f7b5848eb49a1aed5d7d14d198bd3c230df0 Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 15:45:22 +0800 Subject: [PATCH 161/163] fix: Strengthen security by replacing JWT Key and email configuration with environment variables. --- src/main/java/ntou/auction/spring/util/AppConfig.java | 2 ++ src/main/resources/application.properties | 5 +++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/ntou/auction/spring/util/AppConfig.java b/src/main/java/ntou/auction/spring/util/AppConfig.java index 9998a2c..dc1479f 100644 --- a/src/main/java/ntou/auction/spring/util/AppConfig.java +++ b/src/main/java/ntou/auction/spring/util/AppConfig.java @@ -35,4 +35,6 @@ public class AppConfig { private String mailUsername; + private String JWTKey; + } \ No newline at end of file diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 7128d7a..7a94aab 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -13,10 +13,11 @@ spring.jpa.defer-datasource-initialization=true spring.sql.init.mode=always # mail -spring.mail.host=smtp.gmail.com +spring.mail.host=${NA_MAIL_PROVIDER} spring.mail.port=587 spring.mail.username=${NA_MAIL_USER} spring.mail.password=${NA_MAIL_PASSWORD} +app.mail-username=${NA_MAIL_USER} spring.mail.properties.mail.smtp.auth=true spring.mail.properties.mail.smtp.starttls.enable=true @@ -40,6 +41,6 @@ app.newSignupImageSizeLimit=30 # password encoder # BCrypt pbkdf2 argon2 app.idForEncode=argon2 -app.mail-username=${NA_MAIL_USER} +app.JWTKey=${NA_JWT_KEY} From e549c21ae29d153189911df2c3309d452c4f4749 Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 16:11:41 +0800 Subject: [PATCH 162/163] chore: Adjust database DDL auto mode. --- src/main/resources/application.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 7a94aab..1fd37a7 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -4,7 +4,7 @@ server.port=${PORT:8080} # mariadb database # For persistent storage without dropping the database when the app stops, choose the "update" option. # For development mode where the database is created when the app starts and dropped when it stops, choose the "create-drop" option. -spring.jpa.hibernate.ddl-auto=create-drop +spring.jpa.hibernate.ddl-auto=update spring.datasource.url=${NA_DB_URL} spring.datasource.username=${NA_DB_USER} spring.datasource.password=${NA_DB_PASSWORD} From 09f391d8d113c9c45d8ea4bd30dc996b1f18e796 Mon Sep 17 00:00:00 2001 From: keke125 Date: Fri, 22 Dec 2023 16:24:54 +0800 Subject: [PATCH 163/163] fix: Codacy CI. --- .../auction/spring/product/controller/ProductController.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/ntou/auction/spring/product/controller/ProductController.java b/src/main/java/ntou/auction/spring/product/controller/ProductController.java index b79fe13..7a9a7d1 100644 --- a/src/main/java/ntou/auction/spring/product/controller/ProductController.java +++ b/src/main/java/ntou/auction/spring/product/controller/ProductController.java @@ -128,7 +128,6 @@ ResponseEntity> postProduct(@Valid @RequestBody PostNonFixed } @PatchMapping("/bid") - //商品ID 出價。出價也需傳入token ResponseEntity> bidProduct(@Valid @RequestBody BidRequest request) { Map successMessage = Collections.singletonMap("message", "成功出價");