pom.

xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>3.0.1</version>

<relativePath/> <!-- lookup parent from repository -->

</parent>

<groupId>com.examly</groupId>

<artifactId>springapp</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>springapp</name>

<description>Demo project for Spring Boot</description>

<properties>

<java.version>17</java.version>

</properties>

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web-services</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-security</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.security</groupId>

<artifactId>spring-security-test</artifactId>

<scope>test</scope>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

<scope>runtime</scope>

<optional>true</optional>

</dependency>

<dependency>

<groupId>com.mysql</groupId>

<artifactId>mysql-connector-j</artifactId>

<scope>runtime</scope>

</dependency>

<dependency>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

<optional>true</optional>

</dependency>
<!-- <dependency>

<groupId>io.jsonwebtoken</groupId>

<artifactId>jjwt</artifactId>

<version>0.9.1</version>

</dependency> -->

<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt-api -->

<dependency>

<groupId>io.jsonwebtoken</groupId>

<artifactId>jjwt-api</artifactId>

<version>0.11.5</version>

</dependency>

<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt-impl -->

<dependency>

<groupId>io.jsonwebtoken</groupId>

<artifactId>jjwt-impl</artifactId>

<version>0.11.5</version>

</dependency>

<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt-jackson -->

<dependency>

<groupId>io.jsonwebtoken</groupId>

<artifactId>jjwt-jackson</artifactId>

<version>0.11.5</version>

</dependency>

<dependency>

<groupId>javax.xml.bind</groupId>

<artifactId>jaxb-api</artifactId>

<version>2.3.1</version>

</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

<scope>test</scope>

</dependency>

</dependencies>

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

<configuration>

<image>

<builder>paketobuildpacks/builder-jammy-
base:latest</builder>

</image>

<excludes>

<exclude>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

</exclude>

</excludes>

</configuration>

</plugin>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-surefire-plugin</artifactId>

<version>3.0.0-M5</version> <!-- Replace with the latest version -->

<configuration>

<!-- Configuration options go here -->

</configuration>
</plugin>

</plugins>

</build>

</project>

application.properties

spring.jpa.hibernate.ddl-auto=create

spring.datasource.url=jdbc:mysql://localhost/appdb?createDatabaseIfNotExist=true

spring.datasource.username=root

spring.datasource.password=examly

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.show-sql= true

spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect

enable.swagger.plugin=true

spring.mvc.pathmatch.matching-strategy=ant-path-matcher

Model Classes

User.java

package com.examly.springapp.model;

import jakarta.persistence.Column;

import jakarta.persistence.Entity;

import jakarta.persistence.GeneratedValue;

import jakarta.persistence.GenerationType;

import jakarta.persistence.Id;

@Entity

public class User {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private int id;

@Column(unique = true)

private String username;

private String password;

private String role;

public User() {

public User(int id, String username, String password, String role) {

this.id = id;

this.username = username;

this.password = password;

this.role = role;

public int getId() {

return id;

public void setId(int id) {

this.id = id;

public String getUsername() {

return username;

}
public void setUsername(String username) {

this.username = username;

public String getPassword() {

return password;

public void setPassword(String password) {

this.password = password;

public String getRole() {

return role;

public void setRole(String role) {

this.role = role;

@Override

public String toString() {

return "User [id=" + id + ", username=" + username + ", password=" + password + ", role=" + role
+ "]";

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + id;

return result;

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

User other = (User) obj;

if (id != other.id)

return false;

return true;

Gift.java

package com.examly.springapp.model;

import jakarta.persistence.Entity;

import jakarta.persistence.GeneratedValue;

import jakarta.persistence.GenerationType;

import jakarta.persistence.Id;

@Entity

public class Gift {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private int giftId;

private String name;

private String description;

private double price;

public Gift() {

public Gift(int giftId, String name, String description, double price) {

this.giftId = giftId;

this.name = name;

this.description = description;

this.price = price;

public int getGiftId() {

return giftId;

public void setGiftId(int giftId) {

this.giftId = giftId;

public String getName() {

return name;

public void setName(String name) {

this.name = name;

public String getDescription() {

return description;

public void setDescription(String description) {

this.description = description;

public double getPrice() {

return price;

public void setPrice(double price) {

this.price = price;

@Override

public String toString() {

return "Gift [giftId=" + giftId + ", name=" + name + ", description=" + description + ", price=" +
price + "]";

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + giftId;

return result;
}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Gift other = (Gift) obj;

if (giftId != other.giftId)

return false;

return true;

Repositories

UserRepo.java

package com.examly.springapp.repository;

import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;
import com.examly.springapp.model.User;

@Repository

public interface UserRepo extends JpaRepository<User,Integer>{

Optional<User> findByUsername(String username);

GiftRepo.java

package com.examly.springapp.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

import com.examly.springapp.model.Gift;

@Repository

public interface GiftRepo extends JpaRepository<Gift, Integer>{

Exception

UserExistException.java

package com.examly.springapp.exceptions;

public class UserExistException extends RuntimeException{

}
GlobalExceptionAdvice.java

package com.examly.springapp.exceptions;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.security.core.AuthenticationException;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice

public class GlobalExceptionAdvice {

@ExceptionHandler

public ResponseEntity<?> userExistHandler(UserExistException userExistException){

return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(false);

@ExceptionHandler(AuthenticationException.class )

public ResponseEntity<String> handleAuthenticationException(AuthenticationException ex) {

String errmsg="Invalid Credential!! Authentication Failed";

return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(errmsg);

Services

UserService.java

package com.examly.springapp.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;

import org.springframework.stereotype.Service;

import com.examly.springapp.exceptions.UserExistException;

import com.examly.springapp.model.User;

import com.examly.springapp.repository.UserRepo;

@Service

public class UserService {

@Autowired

private UserRepo userRepo;

@Autowired

private PasswordEncoder passwordEncoder;

public boolean registerUser(User user){

User existUser = userRepo.findByUsername(user.getUsername()).orElse(null);

if(existUser != null){

throw new UserExistException();

user.setPassword(passwordEncoder.encode(user.getPassword()));

user = userRepo.save(user);

return true;

}
GiftService.java

package com.examly.springapp.service;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.examly.springapp.model.Gift;

import com.examly.springapp.repository.GiftRepo;

import java.util.List;

@Service

public class GiftService {

@Autowired

private GiftRepo giftRepo;

public Gift addGift(Gift gift){

return giftRepo.save(gift);

public Gift updateGift(Gift gift, int giftId){

gift.setGiftId(giftId);

return giftRepo.save(gift);

public boolean deleteGift(int giftId){

if(giftRepo.existsById(giftId)){

giftRepo.deleteById(giftId);

return true;

}else

return false;
}

public List<Gift> getAllGift(){

return giftRepo.findAll();

public Gift getGiftById(int giftId){

return giftRepo.findById(giftId).orElse(null);

Configuration

JwtUtils.java

package com.examly.springapp.configuration;

import io.jsonwebtoken.Claims;

import io.jsonwebtoken.Jwts;

import io.jsonwebtoken.SignatureAlgorithm;

import io.jsonwebtoken.io.Decoders;

import io.jsonwebtoken.security.Keys;

import org.springframework.security.core.userdetails.UserDetails;

import org.springframework.stereotype.Component;

import java.security.Key;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import java.util.function.Function;
@Component

public class JwtUtils {

public static final String SECRET =

"357638792F423F4428472B4B6250655368566D597133743677397A2443264629";

public String extractUsername(String token) {

return extractClaim(token, Claims::getSubject);

public Date extractExpiration(String token) {

return extractClaim(token, Claims::getExpiration);

public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {

final Claims claims = extractAllClaims(token);

return claimsResolver.apply(claims);

private Claims extractAllClaims(String token) {

return Jwts

.parserBuilder()

.setSigningKey(getSignKey())

.build()

.parseClaimsJws(token)

.getBody();

private Boolean isTokenExpired(String token) {

return extractExpiration(token).before(new Date());

}
public Boolean validateToken(String token, UserDetails userDetails) {

final String username = extractUsername(token);

return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));

public String GenerateToken(String username){

Map<String, Object> claims = new HashMap<>();

return createToken(claims, username);

private String createToken(Map<String, Object> claims, String username) {

return Jwts.builder()

.setClaims(claims)

.setSubject(username)

.setIssuedAt(new Date(System.currentTimeMillis()))

.setExpiration(new Date(System.currentTimeMillis()+1000*60*60))

.signWith(getSignKey(), SignatureAlgorithm.HS256).compact();

private Key getSignKey() {

byte[] keyBytes = Decoders.BASE64.decode(SECRET);

return Keys.hmacShaKeyFor(keyBytes);

}
2

JwtAutheticationEntryPoint.java

package com.examly.springapp.configuration;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.security.web.AuthenticationEntryPoint;

import org.springframework.stereotype.Component;

import org.springframework.web.servlet.HandlerExceptionResolver;

import org.springframework.security.core.AuthenticationException;

import java.io.IOException;

import jakarta.servlet.ServletException;

import jakarta.servlet.http.HttpServletRequest;

import jakarta.servlet.http.HttpServletResponse;

@Component

public class JwtAutheticationEntryPoint implements AuthenticationEntryPoint {

@Autowired

@Qualifier("handlerExceptionResolver")

private HandlerExceptionResolver resolver;

@Override

public void commence(HttpServletRequest request, HttpServletResponse response,

AuthenticationException authException)

throws IOException, ServletException {

resolver.resolveException(request, response, null, authException);

}
3

JwtAuthenticationFilter.java

package com.examly.springapp.configuration;

import jakarta.servlet.FilterChain;

import jakarta.servlet.ServletException;

import jakarta.servlet.http.HttpServletRequest;

import jakarta.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;

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 JwtAuthenticationFilter extends OncePerRequestFilter {

@Autowired

private JwtUtils jwtService;

@Autowired

UserDetailsServiceImpl userDetailsServiceImpl;

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
FilterChain filterChain) throws ServletException, IOException {

String authHeader = request.getHeader("Authorization");

logger.info("Bearer Token : "+authHeader);

String token = null;

String username = null;

if(authHeader != null && authHeader.startsWith("Bearer")){

token = authHeader.substring(7);

logger.info("Token : "+token);

username = jwtService.extractUsername(token);

logger.info("Username from token : "+username);

if(username != null && SecurityContextHolder.getContext().getAuthentication() == null){

UserDetails userDetails = userDetailsServiceImpl.loadUserByUsername(username);

if(jwtService.validateToken(token, userDetails)){

logger.info("Filter validated successfully");

UsernamePasswordAuthenticationToken authenticationToken = new

UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());

authenticationToken.setDetails(new
WebAuthenticationDetailsSource().buildDetails(request));

SecurityContextHolder.getContext().setAuthentication(authenticationToken);

}else{

logger.info("Filter validate failed");

filterChain.doFilter(request, response);

}
}

CustomUserDetails.java

package com.examly.springapp.configuration;

import org.springframework.security.core.GrantedAuthority;

import org.springframework.security.core.authority.SimpleGrantedAuthority;

import org.springframework.security.core.userdetails.UserDetails;

import com.examly.springapp.model.User;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

public class CustomUserDetails extends User implements UserDetails {

private String username;

private String password;

Collection<? extends GrantedAuthority> authorities;

public CustomUserDetails(User byUsername) {

this.username = byUsername.getUsername();

this.password= byUsername.getPassword();

List<GrantedAuthority> auths = new ArrayList<>();

auths.add(new SimpleGrantedAuthority(byUsername.getRole()));

this.authorities = auths;

}
@Override

public Collection<? extends GrantedAuthority> getAuthorities() {

return authorities;

@Override

public String getPassword() {

return password;

@Override

public String getUsername() {

return username;

@Override

public boolean isAccountNonExpired() {

return true;

@Override

public boolean isAccountNonLocked() {

return true;

@Override

public boolean isCredentialsNonExpired() {

return true;

@Override

public boolean isEnabled() {

return true;

UserDetailsServiceImpl.java

package com.examly.springapp.configuration;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.core.userdetails.UserDetails;

import org.springframework.security.core.userdetails.UserDetailsService;

import org.springframework.security.core.userdetails.UsernameNotFoundException;

import org.springframework.stereotype.Component;

import com.examly.springapp.repository.UserRepo;

import com.examly.springapp.model.User;

@Component

public class UserDetailsServiceImpl implements UserDetailsService {

@Autowired

private UserRepo userRepo;

private static final Logger logger = LoggerFactory.getLogger(UserDetailsServiceImpl.class);

@Override

public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

logger.debug("Entering in loadUserByUsername Method...");

User user = userRepo.findByUsername(username).orElse(null);

if(user == null){

logger.error("Username not found: " + username);

throw new UsernameNotFoundException("Invalid username");

logger.info("User Authenticated Successfully..!!!");

logger.info(user+"");

return new CustomUserDetails(user);

SecurityConfig.java

package com.examly.springapp.configuration;

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.AuthenticationProvider;

import org.springframework.security.authentication.dao.DaoAuthenticationProvider;

import
org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfigur
ation;

import
org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;

import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

import org.springframework.security.config.http.SessionCreationPolicy;

import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import org.springframework.security.crypto.password.PasswordEncoder;

import org.springframework.security.web.SecurityFilterChain;

import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration

@EnableWebSecurity

@EnableMethodSecurity

public class SecurityConfig {

@Autowired

UserDetailsService userDetailsService;

@Autowired

JwtAuthenticationFilter jwtAuthenticationFilter;

@Autowired

JwtAutheticationEntryPoint unauthorizedHandler;

@Bean

public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception {

httpSecurity.csrf(csrf -> csrf.disable());

httpSecurity.authorizeHttpRequests(authorizeHttpRequest -> authorizeHttpRequest

.requestMatchers("/auth/login","/auth/register","/api/gift/welcome").permitAll()

.anyRequest().authenticated()

// .requestMatchers("/api/gift","/api/gift/**")

// .authenticated()

);
httpSecurity.sessionManagement(sessionManager ->
sessionManager.sessionCreationPolicy(SessionCreationPolicy.STATELESS));

httpSecurity.exceptionHandling(exceptionHandling ->
exceptionHandling.authenticationEntryPoint(

unauthorizedHandler::commence) );

httpSecurity.authenticationProvider(authenticationProvider());

httpSecurity.addFilterBefore(jwtAuthenticationFilter,
UsernamePasswordAuthenticationFilter.class);

return httpSecurity.build();

// @Bean

// public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

// return http.csrf().disable()

// .authorizeHttpRequests()

// .requestMatchers("/auth/login","/auth/register","/api/gift/welcome")

// .permitAll()

// .and()

// .authorizeHttpRequests()

// .requestMatchers("/api/gift/**")

// .authenticated()

// .and()

// .sessionManagement()

// .sessionCreationPolicy(SessionCreationPolicy.STATELESS)

// .and()

// .exceptionHandling().authenticationEntryPoint(unauthorizedHandler)
// .and()

// .authenticationProvider(authenticationProvider())

// .addFilterBefore(jwtAuthenticationFilter,
UsernamePasswordAuthenticationFilter.class).build();

// }

@Bean

public PasswordEncoder passwordEncoder() {

return new BCryptPasswordEncoder();

@Bean

public AuthenticationProvider authenticationProvider() {

DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();

authenticationProvider.setUserDetailsService(userDetailsService);

authenticationProvider.setPasswordEncoder(passwordEncoder());

return authenticationProvider;

@Bean

public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws

Exception {

return config.getAuthenticationManager();

}
Controller

AuthController.java

package com.examly.springapp.controller;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.userdetails.UsernameNotFoundException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.security.authentication.AuthenticationManager;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RestController;

import com.examly.springapp.configuration.JwtUtils;

import com.examly.springapp.model.User;

import com.examly.springapp.service.UserService;

@RestController

public class AuthController {

@Autowired

private UserService userService;

@Autowired

private JwtUtils jwtService;

@Autowired

private AuthenticationManager authenticationManager;

@PostMapping("/auth/register")

public ResponseEntity<?> registerUser(@RequestBody User user){

System.out.println("************Register : "+user);

userService.registerUser(user);

return ResponseEntity.status(HttpStatus.CREATED).body(true);

@PostMapping("/auth/login")

public String AuthenticateAndGetToken(@RequestBody User user){

Authentication authentication = authenticationManager.authenticate(new

UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword()));

if(authentication.isAuthenticated()){

return jwtService.GenerateToken(user.getUsername());

else {

throw new UsernameNotFoundException("invalid user request..!!");

GiftController.java

package com.examly.springapp.controller;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.security.access.prepost.PreAuthorize;

import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.PutMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RestController;

import com.examly.springapp.model.Gift;

import com.examly.springapp.service.GiftService;

@RestController

public class GiftController {

@Autowired

private GiftService giftService;

@GetMapping("/api/gift/welcome")

@PreAuthorize("permitAll()")

public ResponseEntity<?> welcomeEndPoint(){

return ResponseEntity.status(HttpStatus.OK).body("Welcome to gift application");

@PostMapping("/api/gift")

@PreAuthorize("hasAuthority('ADMIN')")

public ResponseEntity<?> addGift(@RequestBody Gift gift){

return ResponseEntity.status(HttpStatus.CREATED).body(giftService.addGift(gift));

@PutMapping("/api/gift/{giftId}")

@PreAuthorize("hasAuthority('ADMIN')")

public ResponseEntity<?> updateGift(@RequestBody Gift gift, @PathVariable int giftId){

return ResponseEntity.status(HttpStatus.OK).body(giftService.updateGift(gift, giftId));

@DeleteMapping("/api/gift/{giftId}")

@PreAuthorize("hasAuthority('ADMIN')")

public ResponseEntity<?> deleteGift(@PathVariable int giftId){

return ResponseEntity.status(HttpStatus.OK).body(giftService.deleteGift(giftId));

@GetMapping("/api/gift")

@PreAuthorize("permitAll()")

public ResponseEntity<?> getAllGift(){

return ResponseEntity.status(HttpStatus.OK).body(giftService.getAllGift());

@GetMapping("/api/gift/{giftId}")

@PreAuthorize("permitAll()")

public ResponseEntity<?> getGiftById(@PathVariable int giftId){

return ResponseEntity.status(HttpStatus.OK).body(giftService.getGiftById(giftId));