Ad
Untitled
unknown
plain_text
a year ago
23 kB
1
Indexable
Never
-------------UserDao---------------------
package com.org.foodapp.dao;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.query.Param;
import com.org.foodapp.dto.User;
public interface UserDao extends JpaRepository<User, Integer> {
User findByEmailId(@Param("email") String email);
User findByEmail(String email);
}
------------------------------------------------------------------------
----------User.java-----------------------
package com.org.foodapp.dto;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
@NamedQuery(name = "User.findByEmailId", query = "select u from User u where u.email=:email")
@Entity
@DynamicUpdate
@DynamicInsert
@Table(name = "user")
public class User implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Integer id;
@Column(name = "name")
private String name;
@Column(name = "email")
private String email;
@Column(name = "password")
private String password;
@Column(name = "status")
private String status;
@Column(name = "role")
private String role;
public User() {
super();
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
public static long getSerialversionuid() {
return serialVersionUID;
}
}
-------------------------------------------------------------------
-----------------------CustomerUsersDetailsService----------------
package com.org.foodapp.JWT;
import java.util.ArrayList;
import java.util.Objects;
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.Service;
import com.org.foodapp.dao.UserDao;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Service
public class CustomerUsersDetailsService implements UserDetailsService {
@Autowired
UserDao userDao;
private com.org.foodapp.dto.User userDetail;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// log.info("Inside loadUserByUsername {}", username);
userDetail = userDao.findByEmailId(username);
if (!Objects.isNull(userDetail))
return new org.springframework.security.core.userdetails.User(userDetail.getEmail(),userDetail.getPassword(),new ArrayList<>());
else
throw new UsernameNotFoundException("User not found,");
}
public com.org.foodapp.dto.User getUserDetail()
{
return userDetail;
}
}
---------------------------------------------------------------------------------------------
---------------------------JwtFilter-----------------------------------------------
package com.org.foodapp.JWT;
import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.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 com.itextpdf.text.pdf.PdfStructTreeController.returnType;
import io.jsonwebtoken.Claims;
@Component
public class JwtFilter extends OncePerRequestFilter {
@Autowired
private JwtUtil jwtUtil;
@Autowired
private CustomerUsersDetailsService service;
Claims claims = null;
private String userName = null;
@Override
protected void doFilterInternal(HttpServletRequest httpServletrequest, HttpServletResponse httpServletresponse,
FilterChain filterChain) throws ServletException, IOException {
if (httpServletrequest.getServletPath().matches("/user/login|/user/forgotPassword|/user/signup")) {
filterChain.doFilter(httpServletrequest, httpServletresponse);
} else {
String authorizationHeader = httpServletrequest.getHeader("Authorization");
String token = null;
if (authorizationHeader != null && authorizationHeader.startsWith("Bearer")) {
token = authorizationHeader.substring(7);
userName = jwtUtil.extractUsername(token);
claims = jwtUtil.extractAllClaims(token);
}
if (userName != null && SecurityContextHolder.getContext().getAuthentication() == null) {
UserDetails userDetails = service.loadUserByUsername(userName);
if (jwtUtil.validateToken(token, userDetails)) {
UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
userDetails, null, userDetails.getAuthorities());
usernamePasswordAuthenticationToken
.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpServletrequest));
SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
}
}
filterChain.doFilter(httpServletrequest, httpServletresponse);
}
}
public boolean isAdmin() {
return "admin".equalsIgnoreCase((String) claims.get("role"));
}
public boolean isUser() {
return "role".equalsIgnoreCase((String) claims.get("role"));
}
public boolean isBranchManager() {
return "BranchManager".equalsIgnoreCase((String) claims.get("role"));
}
public String getCurrentUser() {
return userName;
}
}
------------------------------------------------------------------------------------------
----------------------------JwtUtil---------------------------------------------
package com.org.foodapp.JWT;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Service;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.sql.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
@Service
public class JwtUtil {
private String secret = "aksav";
public String extractUsername(String token) {
return extractClamis(token, Claims::getSubject);
}
public Date extractExpiration(String token) {
return (Date) extractClamis(token, Claims::getExpiration);
}
public <T> T extractClamis(String token, Function<Claims, T> claimsResolver) {
final Claims claims = extractAllClaims(token);
return claimsResolver.apply(claims);
}
public Claims extractAllClaims(String token) {
return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
}
private Boolean isTokenExpired(String token) {
return extractExpiration(token).before(new Date(0));
}
public String generateToken(String username, String role) {
Map<String, Object> claims = new HashMap<>();
claims.put("role", role);
return createToken(claims, username);
}
private String createToken(Map<String, Object> claims, String subject) {
return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
.setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10)) // Token expires in 10 hours
.signWith(SignatureAlgorithm.HS256, secret).compact();
}
public Boolean validateToken(String token, UserDetails userDetails) {
final String username = extractUsername(token);
return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
}
}
------------------------------------------------------------------------------------------------------
---------------------------------------SecurityConfig--------------------------------------------
package com.org.foodapp.JWT;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.BeanIds;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.WebSecurityConfigurer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
@SuppressWarnings("deprecation")
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
CustomerUsersDetailsService customerUsersDetailsService;
@Autowired
JwtFilter jwtFilter;
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception{
auth.userDetailsService(customerUsersDetailsService);
}
@Bean
public PasswordEncoder passwordEncoder() {
return NoOpPasswordEncoder.getInstance();
}
@Bean(name = BeanIds.AUTHENTICATION_MANAGER)
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.cors().configurationSource(request -> new CorsConfiguration().applyPermitDefaultValues())
.and()
.csrf().disable()
.authorizeRequests()
.antMatchers("/user/login", "/user/singup", "/useer/forgotPassword")
.permitAll()
.anyRequest()
.authenticated()
.and().exceptionHandling()
.and().sessionManagement()
.sessionCreationPolicy(SessionCreationPolicy.STATELESS);
http.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
}
}
----------------------------------------------------------------------------------------
--------------------------FoodConstants-----------------------------------
package com.org.foodapp.model;
public class FoodConstants {
public static final String SOMETHING_WENT_WRONG = "Something Went Wrong";
public static final String INVALID_DATA = "Invalid Data.";
}
----------------------------------------------------------------------------------
--------------------------UserRest----------------------------------
package com.org.foodapp.rest;
import java.util.Map;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
@RequestMapping(path = "/user")
public interface UserRest {
@PostMapping(path = "/signup")
public ResponseEntity<String> signUp(@RequestBody(required = true) Map<String, String> requestMap);
@PostMapping(path = "/login")
public ResponseEntity<String> login(@RequestBody(required = true) Map<String, String> requestMap);
@GetMapping(path = "/checkToken")
ResponseEntity<String> checkToken();
@PostMapping(path = "/changePassword")
ResponseEntity<String> changePassword(@RequestBody Map<String, String> requestMap);
@PostMapping(path = "/forgotPassword")
ResponseEntity<String> forgotPassword(@RequestBody Map<String, String> requestMap);
}
------------------------------------------------------------------------
----------------------------UserRestImpl-------------------------------
package com.org.foodapp.restImpl;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RestController;
import com.org.foodapp.model.FoodConstants;
import com.org.foodapp.rest.UserRest;
import com.org.foodapp.service.UserService;
import com.org.foodapp.utils.FoodUtils;
@RestController
public class UserRestImpl implements UserRest {
@Autowired
UserService userService;
@Override
public ResponseEntity<String> signUp(Map<String, String> requestMap) {
try {
return userService.signUp(requestMap);
} catch (Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
@Override
public ResponseEntity<String> login(Map<String, String> requestMap) {
try {
return userService.login(requestMap);
}catch(Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
@Override
public ResponseEntity<String> checkToken() {
try {
return userService.checkToken();
} catch (Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
@Override
public ResponseEntity<String> changePassword(Map<String, String> requestMap) {
try {
return userService.changePassword(requestMap);
} catch (Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
@Override
public ResponseEntity<String> forgotPassword(Map<String, String> requestMap) {
try {
return userService.forgotPassword(requestMap);
} catch (Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
}
--------------------------------------------------------------------------------------------------
----------------------------------UserService---------------------------------
package com.org.foodapp.service;
import java.util.Map;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
public interface UserService {
ResponseEntity<String> signUp(Map<String, String> requestMap);
ResponseEntity<String> login(Map<String, String> requestMap);
ResponseEntity<String> checkToken();
ResponseEntity<String> changePassword(Map<String, String> requestMap);
ResponseEntity<String> forgotPassword(Map<String, String> requestMap);
}
--------------------------------------------------------------------------------------------
-------------------------------UserServiceImpl-------------------------------------------
package com.org.foodapp.serviceImpl;
import java.util.Map;
import java.util.Objects;
import org.apache.logging.log4j.util.Strings;
import org.apache.tomcat.util.net.openssl.ciphers.Authentication;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.stereotype.Service;
import com.org.foodapp.JWT.CustomerUsersDetailsService;
import com.org.foodapp.JWT.JwtFilter;
import com.org.foodapp.JWT.JwtUtil;
import com.org.foodapp.dao.UserDao;
import com.org.foodapp.dto.User;
import com.org.foodapp.model.FoodConstants;
import com.org.foodapp.service.UserService;
import com.org.foodapp.utils.EmailUtils;
import com.org.foodapp.utils.FoodUtils;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserDao userDao;
@Autowired
AuthenticationManager authenticationManager;
@Autowired
CustomerUsersDetailsService customerUsersDetailsService;
@Autowired
JwtUtil jwtUtil;
@Autowired
JwtFilter jwtFilter;
EmailUtils emailUtils;
@Override
public ResponseEntity<String> signUp(Map<String, String> requestMap) {
// log.info("Inside SignUp {}", requestMap);
try {
if (validateSignUpMap(requestMap)) {
User user = userDao.findByEmailId(requestMap.get("email"));
if (Objects.isNull(user)) {
userDao.save(getUserFromMap(requestMap));
return FoodUtils.getResponseEntity("Successfully Registered", HttpStatus.OK);
} else {
return FoodUtils.getResponseEntity("Email already exists", HttpStatus.BAD_REQUEST);
}
} else {
return FoodUtils.getResponseEntity(FoodConstants.INVALID_DATA, HttpStatus.BAD_REQUEST);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
private boolean validateSignUpMap(Map<String, String> requestMap) {
if (requestMap.containsKey("name") && requestMap.containsKey("email") && requestMap.containsKey("password")) {
return true;
}
return false;
}
@Override
public ResponseEntity<String> login(Map<String, String> requestMap) {
// log.info("Inside login");
try {
org.springframework.security.core.Authentication auth = authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(requestMap.get("email"),requestMap.get("password"))
);
if(auth.isAuthenticated()) {
if(customerUsersDetailsService.getUserDetail().getStatus().equalsIgnoreCase("true")) {
return new ResponseEntity<String>("{\"token\":\""+
jwtUtil.generateToken(customerUsersDetailsService.getUserDetail().getEmail(),
customerUsersDetailsService.getUserDetail().getRole() + "\"}"), HttpStatus.BAD_REQUEST); }
else {
return new ResponseEntity<String>("{\"message\":\""+"Wait for admin approval."+"\")",HttpStatus.BAD_REQUEST);
}
}
}catch(Exception ex) {
// log.error("{}",ex);
}
return new ResponseEntity<String>("{\"message\":\""+"Bad Credentials"+"\")",HttpStatus.BAD_REQUEST);
}
private User getUserFromMap(Map<String, String> requestMap) {
User user = new User();
user.setName(requestMap.get("name"));
user.setPassword(requestMap.get("password"));
user.setEmail(requestMap.get("email"));
user.setStatus("false");
user.setRole("user");
return user;
}
@Override
public ResponseEntity<String> checkToken() {
return FoodUtils.getResponseEntity("true", HttpStatus.OK);
}
@Override
public ResponseEntity<String> changePassword(Map<String, String> requestMap) {
try {
User userObj = userDao.findByEmail(jwtFilter.getCurrentUser());
if (!userObj.equals(null)) {
if (userObj.getPassword().equals(requestMap.get("oldPassword"))) {
userObj.setPassword(requestMap.get("newPassword"));
userDao.save(userObj);
return FoodUtils.getResponseEntity("Password Updated Successfully", HttpStatus.OK);
}
return FoodUtils.getResponseEntity("Incorrect Old Password", HttpStatus.BAD_REQUEST);
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
} catch (Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
@Override
public ResponseEntity<String> forgotPassword(Map<String, String> requestMap) {
try {
User user = userDao.findByEmail(requestMap.get("email"));
if (!Objects.isNull(user) && !Strings.isEmpty(user.getEmail()))
emailUtils.forgotMail(user.getEmail(), "Credentials by Food App", user.getPassword());
return FoodUtils.getResponseEntity("Check your mail for credentials", HttpStatus.OK);
} catch (Exception ex) {
ex.printStackTrace();
}
return FoodUtils.getResponseEntity(FoodConstants.SOMETHING_WENT_WRONG, HttpStatus.INTERNAL_SERVER_ERROR);
}
}
-------------------------------------------------------------------------------------------------------
--------------------------------------EmailUtils-------------------------------------------------------
package com.org.foodapp.utils;
import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import org.springframework.mail.javamail.MimeMessageHelper;
public class EmailUtils {
public void forgotMail(String to, String subject, String password) throws MessagingException {
MimeMessage message = emailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(message, true);
helper.setFrom("");
helper.setTo(to);
helper.setSubject(subject);
String htmlMsg = "<p><b>Your Login details for Food App</b><br><b>Email: </b> " + to + " <br><b>Password: </b> "
+ password + "<br><a href=\"http://localhost:4200/\">Click here to login</a></p>";
message.setContent(htmlMsg, "text/html");
emailSender.send(message);
}
}
---------------------------------------------------------------------------------------------------------------
-------------------------------------------FoodUtils----------------------------------------------------------
package com.org.foodapp.utils;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
public class FoodUtils {
private FoodUtils() {
}
public static ResponseEntity<String> getResponseEntity(String responseMessage, HttpStatus httpStatus){
return new ResponseEntity < String > ("{\"message\":\""+ responseMessage + "\"}", httpStatus);
}
}
----------------------------------------------------------------------------------------------------------------
Ad