added jwt token

omd-dashboard/pom.xml

@@ -23,6 +23,27 @@
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-data-mongodb</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-security</artifactId>
+		</dependency>
+		
+		<dependency>
+			<groupId>io.jsonwebtoken</groupId>
+			<artifactId>jjwt</artifactId>
+			<version>0.9.1</version>
+		</dependency>
+		
+		<dependency>
+			<groupId>org.springframework.security</groupId>
+			<artifactId>spring-security-test</artifactId>
+			<scope>test</scope>
+		</dependency>
 
 		<dependency>
 			<groupId>org.springframework.boot</groupId>

omd-dashboard/src/main/java/com/nisum/omd/controllers/AuthController.java

+package com.nisum.omd.controllers;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import javax.validation.Valid;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.web.bind.annotation.CrossOrigin;
+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 com.nisum.omd.models.ERole;
+import com.nisum.omd.models.Role;
+import com.nisum.omd.models.User;
+import com.nisum.omd.payload.request.LoginRequest;
+import com.nisum.omd.payload.request.SignupRequest;
+import com.nisum.omd.payload.response.JwtResponse;
+import com.nisum.omd.payload.response.MessageResponse;
+import com.nisum.omd.repository.RoleRepository;
+import com.nisum.omd.repository.UserRepository;
+import com.nisum.omd.security.jwt.JwtUtils;
+import com.nisum.omd.security.services.UserDetailsImpl;
+
+
+
+@CrossOrigin(origins = "*", maxAge = 3600)
+@RestController
+@RequestMapping("/api/auth")
+public class AuthController {
+	@Autowired
+	AuthenticationManager authenticationManager;
+
+	@Autowired
+	UserRepository userRepository;
+
+	@Autowired
+	RoleRepository roleRepository;
+
+	@Autowired
+	PasswordEncoder encoder;
+
+	@Autowired
+	JwtUtils jwtUtils;
+
+	@PostMapping("/signin")
+	public ResponseEntity<?> authenticateUser(@Valid @RequestBody LoginRequest loginRequest) {
+
+		Authentication authentication = authenticationManager.authenticate(
+				new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword()));
+
+		SecurityContextHolder.getContext().setAuthentication(authentication);
+		String jwt = jwtUtils.generateJwtToken(authentication);
+		
+		UserDetailsImpl userDetails = (UserDetailsImpl) authentication.getPrincipal();		
+		List<String> roles = userDetails.getAuthorities().stream()
+				.map(item -> item.getAuthority())
+				.collect(Collectors.toList());
+
+		return ResponseEntity.ok(new JwtResponse(jwt, 
+												 userDetails.getId(), 
+												 userDetails.getUsername(), 
+												 userDetails.getEmail(), 
+												 roles));
+	}
+
+	@PostMapping("/signup")
+	public ResponseEntity<?> registerUser(@Valid @RequestBody SignupRequest signUpRequest) {
+		if (userRepository.existsByUsername(signUpRequest.getUsername())) {
+			return ResponseEntity
+					.badRequest()
+					.body(new MessageResponse("Error: Username is already taken!"));
+		}
+
+		if (userRepository.existsByEmail(signUpRequest.getEmail())) {
+			return ResponseEntity
+					.badRequest()
+					.body(new MessageResponse("Error: Email is already in use!"));
+		}
+
+		// Create new user's account
+		User user = new User(signUpRequest.getUsername(), 
+							 signUpRequest.getEmail(),
+							 encoder.encode(signUpRequest.getPassword()));
+
+		Set<String> strRoles = signUpRequest.getRoles();
+		Set<Role> roles = new HashSet<>();
+
+		if (strRoles == null) {
+			Role userRole = roleRepository.findByName(ERole.ROLE_USER)
+					.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
+			roles.add(userRole);
+		} else {
+			strRoles.forEach(role -> {
+				switch (role) {
+				case "admin":
+					Role adminRole = roleRepository.findByName(ERole.ROLE_ADMIN)
+							.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
+					roles.add(adminRole);
+
+					break;
+				case "mod":
+					Role modRole = roleRepository.findByName(ERole.ROLE_MODERATOR)
+							.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
+					roles.add(modRole);
+
+					break;
+				default:
+					Role userRole = roleRepository.findByName(ERole.ROLE_USER)
+							.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
+					roles.add(userRole);
+				}
+			});
+		}
+
+		user.setRoles(roles);
+		userRepository.save(user);
+
+		return ResponseEntity.ok(new MessageResponse("User registered successfully!"));
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/controllers/OrdersController.java

+package com.nisum.omd.controllers;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.nisum.omd.models.OrdersSummary;
+
+
+@CrossOrigin(origins = "*", maxAge = 3600)
+@RestController
+@RequestMapping("/api/test")
+public class OrdersController {
+	static Long dailyOrders=new Long(0);
+	static Long hoursOrders=new Long(0);
+	static Long minutesOrders=new Long(0);
+	static Long customers=new Long(100);
+	@GetMapping(value= "/getOrdersSummary", produces= "application/vnd.jcg.api.v1+json")
+	public OrdersSummary getOrdersCount()
+	{
+		 DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");  
+		   LocalDateTime now = LocalDateTime.now();  
+
+		System.out.println("getOrdersCount:::called at:::"+dtf.format(now));
+		OrdersSummary ordersSummary= new OrdersSummary();
+		ordersSummary.setToday_orders(++dailyOrders);
+		ordersSummary.setToday_date("04/28/2020");
+		ordersSummary.setCurrent_hour_orders(++hoursOrders);
+		ordersSummary.setCurrent_hour("12");
+		ordersSummary.setCurrent_minute_orders(++minutesOrders);
+		ordersSummary.setCurrent_minute("36");
+		ordersSummary.setCustomers_count(++customers);
+		return ordersSummary;
+	}
+	
+	
+}

omd-dashboard/src/main/java/com/nisum/omd/controllers/TestController.java

+package com.nisum.omd.controllers;
+
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@CrossOrigin(origins = "*", maxAge = 3600)
+@RestController
+@RequestMapping("/api/test")
+public class TestController {
+	@GetMapping("/all")
+	public String allAccess() {
+		return "Public Content.";
+	}
+	
+	@GetMapping("/user")
+	@PreAuthorize("hasRole('USER') or hasRole('MODERATOR') or hasRole('ADMIN')")
+	public String userAccess() {
+		return "User Content.";
+	}
+
+	@GetMapping("/mod")
+	@PreAuthorize("hasRole('MODERATOR')")
+	public String moderatorAccess() {
+		return "Moderator Board.";
+	}
+
+	@GetMapping("/admin")
+	@PreAuthorize("hasRole('ADMIN')")
+	public String adminAccess() {
+		return "Admin Board.";
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/models/ERole.java

+package com.nisum.omd.models;
+
+public enum ERole {
+  ROLE_USER,
+  ROLE_MODERATOR,
+  ROLE_ADMIN
+}

omd-dashboard/src/main/java/com/nisum/omd/models/OrdersSummary.java

+package com.nisum.omd.models;
+
+public class OrdersSummary {
+	
+	 private Long id;
+	 private Long today_orders;
+	 private String today_date;
+	 private String current_hour;
+	 private Long current_hour_orders;
+	 private String current_minute;
+	 private Long current_minute_orders;
+	 private Long customers_count;
+	 
+	public Long getToday_orders() {
+		return today_orders;
+	}
+	public void setToday_orders(Long today_orders) {
+		this.today_orders = today_orders;
+	}
+	public String getToday_date() {
+		return today_date;
+	}
+	public void setToday_date(String today_date) {
+		this.today_date = today_date;
+	}
+	public String getCurrent_hour() {
+		return current_hour;
+	}
+	public void setCurrent_hour(String current_hour) {
+		this.current_hour = current_hour;
+	}
+	public Long getCurrent_hour_orders() {
+		return current_hour_orders;
+	}
+	public void setCurrent_hour_orders(Long current_hour_orders) {
+		this.current_hour_orders = current_hour_orders;
+	}
+	public String getCurrent_minute() {
+		return current_minute;
+	}
+	public void setCurrent_minute(String current_minute) {
+		this.current_minute = current_minute;
+	}
+	public Long getCurrent_minute_orders() {
+		return current_minute_orders;
+	}
+	public void setCurrent_minute_orders(Long current_minute_orders) {
+		this.current_minute_orders = current_minute_orders;
+	}
+	public Long getCustomers_count() {
+		return customers_count;
+	}
+	public void setCustomers_count(Long customers_count) {
+		this.customers_count = customers_count;
+	}
+	 
+
+}

omd-dashboard/src/main/java/com/nisum/omd/models/Role.java

+package com.nisum.omd.models;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+@Document(collection = "roles")
+public class Role {
+  @Id
+  private String id;
+
+  private ERole name;
+
+  public Role() {
+
+  }
+
+  public Role(ERole name) {
+    this.name = name;
+  }
+
+  public String getId() {
+    return id;
+  }
+
+  public void setId(String id) {
+    this.id = id;
+  }
+
+  public ERole getName() {
+    return name;
+  }
+
+  public void setName(ERole name) {
+    this.name = name;
+  }
+}

omd-dashboard/src/main/java/com/nisum/omd/models/User.java

+package com.nisum.omd.models;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.Size;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+@Document(collection = "users")
+public class User {
+  @Id
+  private String id;
+
+  @NotBlank
+  @Size(max = 20)
+  private String username;
+
+  @NotBlank
+  @Size(max = 50)
+  @Email
+  private String email;
+
+  @NotBlank
+  @Size(max = 120)
+  private String password;
+
+  @DBRef
+  private Set<Role> roles = new HashSet<>();
+
+  public User() {
+  }
+
+  public User(String username, String email, String password) {
+    this.username = username;
+    this.email = email;
+    this.password = password;
+  }
+
+  public String getId() {
+    return id;
+  }
+
+  public void setId(String id) {
+    this.id = id;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+
+  public void setUsername(String username) {
+    this.username = username;
+  }
+
+  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 Set<Role> getRoles() {
+    return roles;
+  }
+
+  public void setRoles(Set<Role> roles) {
+    this.roles = roles;
+  }
+}

omd-dashboard/src/main/java/com/nisum/omd/payload/request/LoginRequest.java

+package com.nisum.omd.payload.request;
+
+import javax.validation.constraints.NotBlank;
+
+public class LoginRequest {
+	@NotBlank
+	private String username;
+
+	@NotBlank
+	private String password;
+
+	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;
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/payload/request/SignupRequest.java

+package com.nisum.omd.payload.request;
+
+import java.util.Set;
+
+import javax.validation.constraints.*;
+ 
+public class SignupRequest {
+    @NotBlank
+    @Size(min = 3, max = 20)
+    private String username;
+ 
+    @NotBlank
+    @Size(max = 50)
+    @Email
+    private String email;
+    
+    private Set<String> roles;
+    
+    @NotBlank
+    @Size(min = 6, max = 40)
+    private String password;
+  
+    public String getUsername() {
+        return username;
+    }
+ 
+    public void setUsername(String username) {
+        this.username = username;
+    }
+ 
+    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 Set<String> getRoles() {
+      return this.roles;
+    }
+    
+    public void setRole(Set<String> roles) {
+      this.roles = roles;
+    }
+}

omd-dashboard/src/main/java/com/nisum/omd/payload/response/JwtResponse.java

+package com.nisum.omd.payload.response;
+
+import java.util.List;
+
+public class JwtResponse {
+	private String token;
+	private String type = "Bearer";
+	private String id;
+	private String username;
+	private String email;
+	private List<String> roles;
+
+	public JwtResponse(String accessToken, String id, String username, String email, List<String> roles) {
+		this.token = accessToken;
+		this.id = id;
+		this.username = username;
+		this.email = email;
+		this.roles = roles;
+	}
+
+	public String getAccessToken() {
+		return token;
+	}
+
+	public void setAccessToken(String accessToken) {
+		this.token = accessToken;
+	}
+
+	public String getTokenType() {
+		return type;
+	}
+
+	public void setTokenType(String tokenType) {
+		this.type = tokenType;
+	}
+
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	public String getEmail() {
+		return email;
+	}
+
+	public void setEmail(String email) {
+		this.email = email;
+	}
+
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public List<String> getRoles() {
+		return roles;
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/payload/response/MessageResponse.java

+package com.nisum.omd.payload.response;
+
+public class MessageResponse {
+	private String message;
+
+	public MessageResponse(String message) {
+	    this.message = message;
+	  }
+
+	public String getMessage() {
+		return message;
+	}
+
+	public void setMessage(String message) {
+		this.message = message;
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/repository/OrderRepository.java

+package com.nisum.omd.repository;
+
+
+import org.springframework.data.mongodb.repository.MongoRepository;
+
+import com.nisum.omd.models.OrdersSummary;
+
+
+
+public interface OrderRepository extends MongoRepository<OrdersSummary, Long> {
+ 
+}

omd-dashboard/src/main/java/com/nisum/omd/repository/RoleRepository.java

+package com.nisum.omd.repository;
+
+import java.util.Optional;
+
+import org.springframework.data.mongodb.repository.MongoRepository;
+
+import com.nisum.omd.models.ERole;
+import com.nisum.omd.models.Role;
+
+
+public interface RoleRepository extends MongoRepository<Role, String> {
+  Optional<Role> findByName(ERole name);
+}

omd-dashboard/src/main/java/com/nisum/omd/repository/UserRepository.java

+package com.nisum.omd.repository;
+
+import java.util.Optional;
+
+import org.springframework.data.mongodb.repository.MongoRepository;
+
+import com.nisum.omd.models.User;
+
+
+public interface UserRepository extends MongoRepository<User, String> {
+  Optional<User> findByUsername(String username);
+
+  Boolean existsByUsername(String username);
+
+  Boolean existsByEmail(String email);
+}

omd-dashboard/src/main/java/com/nisum/omd/security/WebSecurityConfig.java

+package com.nisum.omd.security;
+
+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.annotation.authentication.builders.AuthenticationManagerBuilder;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+import com.nisum.omd.security.jwt.AuthEntryPointJwt;
+import com.nisum.omd.security.jwt.AuthTokenFilter;
+import com.nisum.omd.security.services.UserDetailsServiceImpl;
+
+
+@Configuration
+@EnableWebSecurity
+@EnableGlobalMethodSecurity(
+		// securedEnabled = true,
+		// jsr250Enabled = true,
+		prePostEnabled = true)
+public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
+	@Autowired
+	UserDetailsServiceImpl userDetailsService;
+
+	@Autowired
+	private AuthEntryPointJwt unauthorizedHandler;
+
+	@Bean
+	public AuthTokenFilter authenticationJwtTokenFilter() {
+		return new AuthTokenFilter();
+	}
+
+	@Override
+	public void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
+		authenticationManagerBuilder.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
+	}
+
+	@Bean
+	@Override
+	public AuthenticationManager authenticationManagerBean() throws Exception {
+		return super.authenticationManagerBean();
+	}
+
+	@Bean
+	public PasswordEncoder passwordEncoder() {
+		return new BCryptPasswordEncoder();
+	}
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http.cors().and().csrf().disable()
+			.exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
+			.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
+			.authorizeRequests().antMatchers("/api/auth/**").permitAll()
+			.antMatchers("/api/test/**").permitAll()
+			.anyRequest().authenticated();
+
+		http.addFilterBefore(authenticationJwtTokenFilter(), UsernamePasswordAuthenticationFilter.class);
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/security/jwt/AuthEntryPointJwt.java

+package com.nisum.omd.security.jwt;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.AuthenticationEntryPoint;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AuthEntryPointJwt implements AuthenticationEntryPoint {
+
+	private static final Logger logger = LoggerFactory.getLogger(AuthEntryPointJwt.class);
+
+	@Override
+	public void commence(HttpServletRequest request, HttpServletResponse response,
+			AuthenticationException authException) throws IOException, ServletException {
+		logger.error("Unauthorized error: {}", authException.getMessage());
+		response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Error: Unauthorized");
+	}
+
+}

omd-dashboard/src/main/java/com/nisum/omd/security/jwt/AuthTokenFilter.java

+package com.nisum.omd.security.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.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+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.util.StringUtils;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import com.nisum.omd.security.services.UserDetailsServiceImpl;
+
+
+public class AuthTokenFilter extends OncePerRequestFilter {
+  @Autowired
+  private JwtUtils jwtUtils;
+
+  @Autowired
+  private UserDetailsServiceImpl userDetailsService;
+
+  private static final Logger logger = LoggerFactory.getLogger(AuthTokenFilter.class);
+
+  @Override
+  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
+      throws ServletException, IOException {
+    try {
+      String jwt = parseJwt(request);
+      if (jwt != null && jwtUtils.validateJwtToken(jwt)) {
+        String username = jwtUtils.getUserNameFromJwtToken(jwt);
+
+        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
+        UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null,
+            userDetails.getAuthorities());
+        authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
+
+        SecurityContextHolder.getContext().setAuthentication(authentication);
+      }
+    } catch (Exception e) {
+      logger.error("Cannot set user authentication: {}", e);
+    }
+
+    filterChain.doFilter(request, response);
+  }
+
+  private String parseJwt(HttpServletRequest request) {
+    String headerAuth = request.getHeader("Authorization");
+
+    if (StringUtils.hasText(headerAuth) && headerAuth.startsWith("Bearer ")) {
+      return headerAuth.substring(7, headerAuth.length());
+    }
+
+    return null;
+  }
+}

omd-dashboard/src/main/java/com/nisum/omd/security/jwt/JwtUtils.java

+package com.nisum.omd.security.jwt;
+
+import java.util.Date;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.core.Authentication;
+import org.springframework.stereotype.Component;
+
+import com.nisum.omd.security.services.UserDetailsImpl;
+
+import io.jsonwebtoken.*;
+
+@Component
+public class JwtUtils {
+	private static final Logger logger = LoggerFactory.getLogger(JwtUtils.class);
+
+	@Value("${bezkoder.app.jwtSecret}")
+	private String jwtSecret;
+
+	@Value("${bezkoder.app.jwtExpirationMs}")
+	private int jwtExpirationMs;
+
+	public String generateJwtToken(Authentication authentication) {
+
+		UserDetailsImpl userPrincipal = (UserDetailsImpl) authentication.getPrincipal();
+
+		return Jwts.builder()
+				.setSubject((userPrincipal.getUsername()))
+				.setIssuedAt(new Date())
+				.setExpiration(new Date((new Date()).getTime() + jwtExpirationMs))
+				.signWith(SignatureAlgorithm.HS512, jwtSecret)
+				.compact();
+	}
+
+	public String getUserNameFromJwtToken(String token) {
+		return Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(token).getBody().getSubject();
+	}
+
+	public boolean validateJwtToken(String authToken) {
+		try {
+			Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);
+			return true;
+		} catch (SignatureException e) {
+			logger.error("Invalid JWT signature: {}", e.getMessage());
+		} catch (MalformedJwtException e) {
+			logger.error("Invalid JWT token: {}", e.getMessage());
+		} catch (ExpiredJwtException e) {
+			logger.error("JWT token is expired: {}", e.getMessage());
+		} catch (UnsupportedJwtException e) {
+			logger.error("JWT token is unsupported: {}", e.getMessage());
+		} catch (IllegalArgumentException e) {
+			logger.error("JWT claims string is empty: {}", e.getMessage());
+		}
+
+		return false;
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/security/services/UserDetailsImpl.java

+package com.nisum.omd.security.services;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+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 com.fasterxml.jackson.annotation.JsonIgnore;
+import com.nisum.omd.models.User;
+
+public class UserDetailsImpl implements UserDetails {
+	private static final long serialVersionUID = 1L;
+
+	private String id;
+
+	private String username;
+
+	private String email;
+
+	@JsonIgnore
+	private String password;
+
+	private Collection<? extends GrantedAuthority> authorities;
+
+	public UserDetailsImpl(String id, String username, String email, String password,
+			Collection<? extends GrantedAuthority> authorities) {
+		this.id = id;
+		this.username = username;
+		this.email = email;
+		this.password = password;
+		this.authorities = authorities;
+	}
+
+	public static UserDetailsImpl build(User user) {
+		List<GrantedAuthority> authorities = user.getRoles().stream()
+				.map(role -> new SimpleGrantedAuthority(role.getName().name()))
+				.collect(Collectors.toList());
+
+		return new UserDetailsImpl(
+				user.getId(), 
+				user.getUsername(), 
+				user.getEmail(),
+				user.getPassword(), 
+				authorities);
+	}
+
+	@Override
+	public Collection<? extends GrantedAuthority> getAuthorities() {
+		return authorities;
+	}
+
+	public String getId() {
+		return id;
+	}
+
+	public String getEmail() {
+		return email;
+	}
+
+	@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;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o)
+			return true;
+		if (o == null || getClass() != o.getClass())
+			return false;
+		UserDetailsImpl user = (UserDetailsImpl) o;
+		return Objects.equals(id, user.id);
+	}
+}

omd-dashboard/src/main/java/com/nisum/omd/security/services/UserDetailsServiceImpl.java

+package com.nisum.omd.security.services;
+
+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 org.springframework.transaction.annotation.Transactional;
+
+import com.nisum.omd.models.User;
+import com.nisum.omd.repository.UserRepository;
+
+
+@Service
+public class UserDetailsServiceImpl implements UserDetailsService {
+	@Autowired
+	UserRepository userRepository;
+
+	@Override
+	@Transactional
+	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+		User user = userRepository.findByUsername(username)
+				.orElseThrow(() -> new UsernameNotFoundException("User Not Found with username: " + username));
+
+		return UserDetailsImpl.build(user);
+	}
+
+}

omd-dashboard/src/main/resources/application.properties

 
+spring.data.mongodb.database=omd_dashboard_db
+spring.data.mongodb.host=localhost
+spring.data.mongodb.port=27017
+mongodb-script-1=inserts.jnosql
+
+# App Properties
+bezkoder.app.jwtSecret= bezKoderSecretKey
+bezkoder.app.jwtExpirationMs= 86400000
+server.port=9009
\ No newline at end of file

omd-dashboard/src/main/resources/insert.jnosql

+insert roles (name = "ROLE_USER")
+insert roles (name = "ROLE_MODERATOR")
+insert roles (name = "ROLE_ADMIN")
\ No newline at end of file