diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b937cae8d67980ee2105facf93b71583ba79724e
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,114 @@
+<?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>2.7.1</version>
+ <relativePath/> <!-- lookup parent from repository -->
+ </parent>
+ <groupId>org.upsmf</groupId>
+ <artifactId>grievance</artifactId>
+ <version>0.0.1-SNAPSHOT</version>
+ <name>Grievance Service</name>
+ <description>Customised service for grievance workflow </description>
+ <properties>
+ <java.version>11</java.version>
+ <firebase-admin.version>9.2.0</firebase-admin.version>
+ </properties>
+ <dependencies>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-actuator</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-security</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.security</groupId>
+ <artifactId>spring-security-jwt</artifactId>
+ <version>1.1.0.RELEASE</version>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.security.oauth</groupId>
+ <artifactId>spring-security-oauth2</artifactId>
+ <version>2.5.0.RELEASE</version>
+ </dependency>
+ <dependency>
+ <groupId>io.jsonwebtoken</groupId>
+ <artifactId>jjwt</artifactId>
+ <version>0.6.0</version>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-data-jpa</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.google.cloud</groupId>
+ <artifactId>google-cloud-storage</artifactId>
+ <version>2.26.0</version>
+ </dependency>
+ <dependency>
+ <groupId>org.postgresql</groupId>
+ <artifactId>postgresql</artifactId>
+ <version>42.6.0</version>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-data-redis</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-mail</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-web</artifactId>
+ </dependency>
+ <!-- https://mvnrepository.com/artifact/com.google.firebase/firebase-admin -->
+ <dependency>
+ <groupId>com.google.firebase</groupId>
+ <artifactId>firebase-admin</artifactId>
+ <version>${firebase-admin.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.projectlombok</groupId>
+ <artifactId>lombok</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-test</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-artifact-manager</artifactId>
+ <version>2.0</version>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-maven-plugin</artifactId>
+ <configuration>
+ <excludes>
+ <exclude>
+ <groupId>org.projectlombok</groupId>
+ <artifactId>lombok</artifactId>
+ </exclude>
+ </excludes>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/src/main/.DS_Store b/src/main/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..2c2c05dc581d4df18e116503e9c1227aa6568f9c
Binary files /dev/null and b/src/main/.DS_Store differ
diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..3b55b64a6de9e0092ed80c725c3629a6ae64f0e1
Binary files /dev/null and b/src/main/java/.DS_Store differ
diff --git a/src/main/java/org/.DS_Store b/src/main/java/org/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..edee1968e0bf39036c17cae926de537a5da84921
Binary files /dev/null and b/src/main/java/org/.DS_Store differ
diff --git a/src/main/java/org/upsmf/.DS_Store b/src/main/java/org/upsmf/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..2c81699741227b09e795aed149a6197996a1c3d0
Binary files /dev/null and b/src/main/java/org/upsmf/.DS_Store differ
diff --git a/src/main/java/org/upsmf/grievance/.DS_Store b/src/main/java/org/upsmf/grievance/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..39347aeaeebb37622c509c1e058726a467b72398
Binary files /dev/null and b/src/main/java/org/upsmf/grievance/.DS_Store differ
diff --git a/src/main/java/org/upsmf/grievance/GrievanceServiceApplication.java b/src/main/java/org/upsmf/grievance/GrievanceServiceApplication.java
new file mode 100644
index 0000000000000000000000000000000000000000..7cbe26cdc008b1662db7cde24f26c243955f1cbe
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/GrievanceServiceApplication.java
@@ -0,0 +1,15 @@
+package org.upsmf.grievance;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+@SpringBootApplication
+@EnableJpaRepositories(basePackages = "org.upsmf.grievance")
+public class GrievanceServiceApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(GrievanceServiceApplication.class, args);
+ }
+
+}
diff --git a/src/main/java/org/upsmf/grievance/config/EsConfig.java b/src/main/java/org/upsmf/grievance/config/EsConfig.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3f7feab684afd385435b2e93ffdf502d1c73c0d
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/config/EsConfig.java
@@ -0,0 +1,45 @@
+package org.upsmf.grievance.config;
+
+import lombok.extern.slf4j.Slf4j;
+import org.elasticsearch.client.RestHighLevelClient;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.elasticsearch.client.ClientConfiguration;
+import org.springframework.data.elasticsearch.client.RestClients;
+import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;
+import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
+
+@Configuration
+@EnableElasticsearchRepositories(basePackages = "org.upsmf.grievance")
+@Slf4j
+public class EsConfig extends AbstractElasticsearchConfiguration {
+
+ @Value("${spring.data.elasticsearch.rest.uris}")
+ private String host;
+
+ private String port = "9200";
+
+ public String getHost() {
+ return host;
+ }
+
+ public void setHost(String host) {
+ this.host = host;
+ }
+
+ public String getPort() {
+ return port;
+ }
+
+ public void setPort(String port) {
+ this.port = port;
+ }
+
+ @Override
+ public RestHighLevelClient elasticsearchClient() {
+ final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
+ .connectedTo(host)
+ .build();
+ return RestClients.create(clientConfiguration).rest();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/org/upsmf/grievance/config/JwtAuthenticationEntryPoint.java b/src/main/java/org/upsmf/grievance/config/JwtAuthenticationEntryPoint.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b657acc5d3d778b409ded52362ce8d1a5bcd0ee
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/config/JwtAuthenticationEntryPoint.java
@@ -0,0 +1,30 @@
+package org.upsmf.grievance.config;
+
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.AuthenticationEntryPoint;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.Serializable;
+
+@Component
+public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable {
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ public void commence(javax.servlet.http.HttpServletRequest httpServletRequest,
+ HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
+ /* ServletContext ctx = httpServletRequest.getServletContext();
+ if (!(Boolean) ctx.getAttribute("WhiteList")) {
+ httpServletResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
+ }*/
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/org/upsmf/grievance/config/JwtAuthenticationFilter.java b/src/main/java/org/upsmf/grievance/config/JwtAuthenticationFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..65304246de8ae523a01b4772b70df66f95ad9ef6
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/config/JwtAuthenticationFilter.java
@@ -0,0 +1,123 @@
+package org.upsmf.grievance.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+ /*@Autowired
+ private UserService userService;
+
+ @Autowired
+ private JwtTokenUtil jwtTokenUtil;*/
+
+ @Value("${urls.whitelist}")
+ private String whitelistUrls;
+
+ @Override
+ protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
+ throws IOException, ServletException {
+
+
+ /*List<String> whitelistUrlList = Arrays.asList(whitelistUrls.split(","));
+
+ ServletContext ctx = req.getServletContext();
+ Boolean whiteListed;
+ Boolean authorized = Boolean.FALSE;
+ String username = null;
+ String authToken = null;
+ UserDetails userDetails = null;
+ Map<String, Object> userInfoObectMap = new HashMap<>();
+
+ if (whitelistUrlList.contains(req.getRequestURI())) {
+ whiteListed = Boolean.TRUE;
+ } else {
+ whiteListed = Boolean.FALSE;
+ String header = req.getHeader(HEADER_STRING);
+ if (StringUtils.isBlank(header)) {
+ res.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+ res.getWriter()
+ .write(ResponseGenerator.failureResponse(ResponseMessages.ErrorMessages.UNAUTHORIZED_ACCESS));
+ res.setContentType("application/json");
+ res.getWriter().flush();
+ return;
+ }
+ if (header.startsWith(TOKEN_PREFIX)) {
+ authToken = header.replace(TOKEN_PREFIX, "");
+ username = getUserName(username, authToken);
+ } else {
+ logger.warn("couldn't find bearer string, will ignore the header");
+ }
+ if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+ userInfoObectMap = userService.getUserInfoObjects(username);
+ userDetails = (UserDetails) userInfoObectMap.get("UserDetails");
+ if (jwtTokenUtil.validateToken(authToken, userDetails)) {
+ UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
+ userDetails, null, Arrays.asList(new SimpleGrantedAuthority("ROLE_ADMIN")));
+ authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(req));
+ logger.info("authenticated user " + username + ", setting security context");
+ SecurityContextHolder.getContext().setAuthentication(authentication);
+ }
+ }
+
+
+ Boolean userTokenAvailable = userService.findUserByToken(authToken);
+ authorized = checkForAuthorization(req, ctx, authorized, userDetails, userInfoObectMap, userTokenAvailable);
+ }
+
+ if (!authorized && !whiteListed) {
+ res.setStatus(HttpServletResponse.SC_FORBIDDEN);
+ res.getWriter()
+ .write(ResponseGenerator.failureResponse(ResponseMessages.ErrorMessages.INVALID_ACCESS_ROLE));
+ res.setContentType("application/json");
+ res.getWriter().flush();
+ return;
+ }*/
+
+ chain.doFilter(req, res);
+ }
+
+ /*public String getUserName(String username, String authToken) {
+ try {
+ username = jwtTokenUtil.getUsernameFromToken(authToken);
+ } catch (IllegalArgumentException e) {
+ logger.error("an error occured during getting username from token", e);
+ } catch (ExpiredJwtException e) {
+ logger.warn("the token is expired and not valid anymore", e);
+ } catch (SignatureException e) {
+ logger.error("Authentication Failed. Username or Password not valid.");
+ }
+ return username;
+ }
+
+ public Boolean checkForAuthorization(HttpServletRequest req, ServletContext ctx, Boolean authorized,
+ UserDetails userDetails, Map<String, Object> userInfoObectMap, Boolean userTokenAvailable) {
+ if (userTokenAvailable) {
+ try {
+ if (userDetails != null) {
+ User user = (User) userInfoObectMap.get("User");
+ req.setAttribute("UserInfo", user);
+ ctx.setAttribute("UserInfo", user);
+ List<Long> roleIds = MasterDataManager.getRoleIdsForUserId(user.getId());
+ for (Long roleId : roleIds) {
+ List<String> actionUrlList = MasterDataManager.getActionUrlsForRoleId(roleId);
+ if (actionUrlList.contains(req.getRequestURI())) {
+ ctx.setAttribute("Authorized", Boolean.TRUE);
+ authorized = Boolean.TRUE;
+ break;
+ }
+ }
+ }
+ } catch (UsernameNotFoundException e) {
+ e.getMessage();
+ }
+ }
+ return authorized;
+ }*/
+}
\ No newline at end of file
diff --git a/src/main/java/org/upsmf/grievance/config/WebSecurityConfig.java b/src/main/java/org/upsmf/grievance/config/WebSecurityConfig.java
new file mode 100644
index 0000000000000000000000000000000000000000..666baf64eb8f4ba9897650b73845b074c661c0eb
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/config/WebSecurityConfig.java
@@ -0,0 +1,62 @@
+package org.upsmf.grievance.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+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.core.userdetails.UserDetailsService;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+
+import javax.annotation.Resource;
+
+@Configuration
+@EnableWebSecurity
+@EnableGlobalMethodSecurity(prePostEnabled = true)
+public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
+
+ /*@Resource(name = "userService")
+ private UserDetailsService userDetailsService;*/
+
+ @Autowired
+ private JwtAuthenticationEntryPoint unauthorizedHandler;
+
+ @Value("${urls.whitelist}")
+ private String whiteListUrls;
+
+ /*@Override
+ @Bean
+ public AuthenticationManager authenticationManagerBean() throws Exception {
+ return super.authenticationManagerBean();
+ }*/
+
+ /*@Autowired
+ public void globalUserDetails(AuthenticationManagerBuilder auth) throws Exception {
+ auth.userDetailsService(userDetailsService).passwordEncoder(encoder());
+ }*/
+
+ @Bean
+ public JwtAuthenticationFilter authenticationTokenFilterBean() {
+ return new JwtAuthenticationFilter();
+ }
+
+ @Override
+ protected void configure(HttpSecurity http) throws Exception {
+ /*http.cors().and().csrf().disable().authorizeRequests().antMatchers("/**").permitAll().anyRequest()
+ .authenticated().and().exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
+ .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
+ http.addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);*/
+ http.cors().and().csrf().disable().authorizeRequests().antMatchers("/**").permitAll();
+ }
+
+ @Bean
+ public BCryptPasswordEncoder encoder() {
+ return new BCryptPasswordEncoder();
+ }
+
+}
diff --git a/src/main/java/org/upsmf/grievance/constants/Constants.java b/src/main/java/org/upsmf/grievance/constants/Constants.java
new file mode 100644
index 0000000000000000000000000000000000000000..86f54633e2b0d5e8a3db99b432d35b2d5967b063
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/constants/Constants.java
@@ -0,0 +1,6 @@
+package org.upsmf.grievance.constants;
+
+public class Constants {
+
+ public static final String TIME_ZONE = "Asia/Kolkata";
+}
diff --git a/src/main/java/org/upsmf/grievance/controller/FeedbackController.java b/src/main/java/org/upsmf/grievance/controller/FeedbackController.java
new file mode 100644
index 0000000000000000000000000000000000000000..67b3f46fd943a1b0b11100d78c96c4654875715a
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/controller/FeedbackController.java
@@ -0,0 +1,32 @@
+package org.upsmf.grievance.controller;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+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;
+import org.upsmf.grievance.dto.FeedbackDto;
+import org.upsmf.grievance.model.reponse.Response;
+import org.upsmf.grievance.service.FeedbackService;
+
+@Controller
+@RequestMapping("/feedback")
+public class FeedbackController {
+
+ @Autowired
+ private FeedbackService feedbackService;
+
+ @PostMapping("/save")
+ public ResponseEntity saveFeedback(@RequestBody FeedbackDto feedbackDto) {
+ feedbackService.saveFeedback(feedbackDto);
+ return new ResponseEntity(HttpStatus.OK);
+ }
+
+ @GetMapping("/all")
+ public ResponseEntity<Response> getFeedbacks() {
+ return new ResponseEntity<Response>(new Response(HttpStatus.OK.value(), feedbackService.getFeedbacks()), HttpStatus.OK);
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/controller/OtpController.java b/src/main/java/org/upsmf/grievance/controller/OtpController.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae50323f5892d10a20043846d6de0badfba95ef1
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/controller/OtpController.java
@@ -0,0 +1,43 @@
+package org.upsmf.grievance.controller;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+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.upsmf.grievance.model.OtpRequest;
+import org.upsmf.grievance.model.OtpValidationRequest;
+import org.upsmf.grievance.service.OtpService;
+
+@RestController
+@RequestMapping("/otp")
+public class OtpController {
+
+ @Autowired
+ private OtpService otpService;
+
+ @PostMapping("/generate-otp")
+ public ResponseEntity<String> generateOtp(@RequestBody OtpRequest otpRequest) {
+ try {
+ otpService.generateAndSendOtp(otpRequest);
+ return ResponseEntity.ok("OTP generated and sent successfully to " + otpRequest.getEmail());
+ } catch (Exception e) {
+ return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+ .body("Failed to generate and send OTP: " + e.getMessage());
+ }
+ }
+
+ @PostMapping("/validate-otp")
+ public ResponseEntity<String> validateOtp(@RequestBody OtpValidationRequest otpValidationRequest) {
+ boolean isValid = otpService.validateOtp(otpValidationRequest.getEmail(), otpValidationRequest.getOtp());
+ if (isValid) {
+ return ResponseEntity.ok("OTP validation successful.");
+ } else {
+ return ResponseEntity.badRequest().body("Invalid OTP.");
+ }
+ }
+
+
+}
diff --git a/src/main/java/org/upsmf/grievance/controller/SearchTicketController.java b/src/main/java/org/upsmf/grievance/controller/SearchTicketController.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f745a5c80e5a57cb8fe1a492b6266e4589b3a93
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/controller/SearchTicketController.java
@@ -0,0 +1,31 @@
+package org.upsmf.grievance.controller;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.upsmf.grievance.dto.SearchRequest;
+import org.upsmf.grievance.model.es.Ticket;
+import org.upsmf.grievance.model.reponse.Response;
+import org.upsmf.grievance.model.reponse.TicketResponse;
+import org.upsmf.grievance.service.SearchService;
+
+import java.util.Optional;
+
+@Controller
+@RequestMapping("/search")
+public class SearchTicketController {
+
+ @Autowired
+ private SearchService searchService;
+
+ @PostMapping("/getAllTickets")
+ public ResponseEntity<Response> search(SearchRequest searchRequest){
+ TicketResponse responseTicket = searchService.search(searchRequest);
+ Response response = new Response(HttpStatus.OK.value(), responseTicket);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/org/upsmf/grievance/controller/TicketController.java b/src/main/java/org/upsmf/grievance/controller/TicketController.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b7532a70ebb04cc5a4ff76439e9ca1aff2b956d
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/controller/TicketController.java
@@ -0,0 +1,62 @@
+package org.upsmf.grievance.controller;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import org.upsmf.grievance.dto.FileUploadRequest;
+import org.upsmf.grievance.model.Ticket;
+import org.upsmf.grievance.model.reponse.Response;
+import org.upsmf.grievance.dto.TicketRequest;
+import org.upsmf.grievance.dto.UpdateTicketRequest;
+import org.upsmf.grievance.service.AttachmentService;
+import org.upsmf.grievance.service.TicketService;
+
+@Controller
+@RequestMapping("/ticket")
+public class TicketController {
+
+ @Autowired
+ private TicketService ticketService;
+
+ @Autowired
+ private AttachmentService attachmentService;
+
+ @PostMapping("/save")
+ public ResponseEntity<Response> save(@RequestBody TicketRequest ticketRequest) {
+ Ticket responseTicket = null;
+ try {
+ responseTicket = ticketService.save(ticketRequest);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ Response response = new Response(HttpStatus.OK.value(), responseTicket);
+ return new ResponseEntity<Response>(response, HttpStatus.OK);
+ }
+
+ @PostMapping("/update")
+ public ResponseEntity<Response> update(@RequestBody UpdateTicketRequest updateTicketRequest) {
+ Ticket responseTicket = ticketService.update(updateTicketRequest);
+ Response response = new Response(HttpStatus.OK.value(), responseTicket);
+ return new ResponseEntity<Response>(response, HttpStatus.OK);
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity<Response> update(@RequestParam(name = "id") long id) {
+ Ticket responseTicket = ticketService.getTicketById(id);
+ Response response = new Response(HttpStatus.OK.value(), responseTicket);
+ return new ResponseEntity<Response>(response, HttpStatus.OK);
+ }
+
+ @PostMapping("/file/upload")
+ public ResponseEntity upload(@RequestBody FileUploadRequest fileUploadRequest) {
+ Ticket responseTicket = null;
+ try {
+ attachmentService.uploadObject(fileUploadRequest);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ return new ResponseEntity(HttpStatus.OK);
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/dto/ErrorResponseDto.java b/src/main/java/org/upsmf/grievance/dto/ErrorResponseDto.java
new file mode 100644
index 0000000000000000000000000000000000000000..64c60db198f6931119fdc51cb1d3ba36de961c81
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/dto/ErrorResponseDto.java
@@ -0,0 +1,22 @@
+package org.upsmf.grievance.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ErrorResponseDto {
+
+ private int statusCode;
+ private String message;
+
+ public ErrorResponseDto(String message)
+ {
+ super();
+ this.message = message;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/org/upsmf/grievance/dto/FeedbackDto.java b/src/main/java/org/upsmf/grievance/dto/FeedbackDto.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fb302a53ab225739ec5b351e9ae8e1a768c080e
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/dto/FeedbackDto.java
@@ -0,0 +1,19 @@
+package org.upsmf.grievance.dto;
+
+import lombok.*;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@ToString(includeFieldNames = true)
+public class FeedbackDto {
+
+ private String firstName;
+ private String lastName;
+ private String phone;
+ private String email;
+ private Integer rating;
+ private String comment;
+}
diff --git a/src/main/java/org/upsmf/grievance/dto/FileUploadRequest.java b/src/main/java/org/upsmf/grievance/dto/FileUploadRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..569bdf7d245298109f2f46e84944a4087bdf0be6
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/dto/FileUploadRequest.java
@@ -0,0 +1,21 @@
+package org.upsmf.grievance.dto;
+
+import lombok.*;
+
+import java.io.File;
+import java.sql.Timestamp;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@ToString
+public class FileUploadRequest {
+
+ private File file;
+ private String fileName;
+ private String fileExtension;
+ private Timestamp createdDate;
+ private Timestamp updatedDate;
+ private Long uploadedBy;
+}
diff --git a/src/main/java/org/upsmf/grievance/dto/SearchRequest.java b/src/main/java/org/upsmf/grievance/dto/SearchRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7678f6c294fbc19abefe4dd993e53aec3c7412b
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/dto/SearchRequest.java
@@ -0,0 +1,37 @@
+package org.upsmf.grievance.dto;
+
+import lombok.*;
+import org.upsmf.grievance.enums.TicketPriority;
+
+import java.sql.Timestamp;
+import java.util.List;
+import java.util.Map;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class SearchRequest {
+
+ private String searchKeyword;
+
+ private Map<String,Object> filter;
+
+ private List<String> status;
+
+ private String cc;
+
+ private Timestamp date;
+
+ private Boolean isJunk;
+
+ private TicketPriority priority;
+
+ private int offset;
+
+ private int size;
+
+ private Map<String, String> sort;
+
+}
diff --git a/src/main/java/org/upsmf/grievance/dto/TicketRequest.java b/src/main/java/org/upsmf/grievance/dto/TicketRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..027666da643f2240c60fc6d9a7fa396bd54e247d
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/dto/TicketRequest.java
@@ -0,0 +1,27 @@
+package org.upsmf.grievance.dto;
+
+import lombok.*;
+import org.upsmf.grievance.enums.RequesterType;
+
+import java.util.List;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@ToString(includeFieldNames = true)
+public class TicketRequest {
+
+ private String firstName;
+ private String lastName;
+ private String email;
+ private String phone;
+ private RequesterType userType;
+ private Long cc;
+ private String requestType;
+ private String description;
+ private List<String> attachmentURls;
+ private String otp;
+
+}
diff --git a/src/main/java/org/upsmf/grievance/dto/UpdateTicketRequest.java b/src/main/java/org/upsmf/grievance/dto/UpdateTicketRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..562c1db1d489ec169347cfa6d1c7cc9bc9313d69
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/dto/UpdateTicketRequest.java
@@ -0,0 +1,30 @@
+package org.upsmf.grievance.dto;
+
+import lombok.*;
+import org.upsmf.grievance.enums.TicketPriority;
+import org.upsmf.grievance.enums.TicketStatus;
+
+import java.util.List;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@ToString(includeFieldNames = true)
+public class UpdateTicketRequest {
+
+ private long id;
+ private long requestedBy;
+ private TicketStatus status;
+ private Long cc;//AssignedTo
+ private TicketPriority priority;
+ private String comment;
+ private List<String> assigneeAttachmentURLs;
+ private Boolean isJunk;
+ //nodal office -
+ // mark as resolved - status - closed,
+ // others cc = -1
+ // junk - update status as closed, isJunk
+ // attachment url -
+}
diff --git a/src/main/java/org/upsmf/grievance/enums/ErrorCode400.java b/src/main/java/org/upsmf/grievance/enums/ErrorCode400.java
new file mode 100755
index 0000000000000000000000000000000000000000..86300cf9f4198bc5e4189c5d39bf1aed88d0f540
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/enums/ErrorCode400.java
@@ -0,0 +1,24 @@
+package org.upsmf.grievance.enums;
+
+public enum ErrorCode400 {
+ INVALID_REQUEST("GVS-400-001","Invalid Request"),
+ MISSING_AUTH_TOKEN("GVS-400-002","Missing Auth Token"),
+ UNAUTHORIZED_REQUEST("GVS-400-003","Invalid Access Token"),
+ INVALID_REFRESH_TOKEN("GVS-400-004","Invalid Refresh Token");
+
+ private String code;
+ private String message;
+
+ ErrorCode400(String code, String message) {
+ this.code = code;
+ this.message = message;
+ }
+
+ public String getCode() {
+ return code;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/enums/ErrorCode422.java b/src/main/java/org/upsmf/grievance/enums/ErrorCode422.java
new file mode 100755
index 0000000000000000000000000000000000000000..13f6c203b47aa76be3940959cf9ce0cf1ac81726
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/enums/ErrorCode422.java
@@ -0,0 +1,22 @@
+package org.upsmf.grievance.enums;
+
+public enum ErrorCode422 {
+ UNABLE_TO_FETCH_PROFILE("GVS-422-001","Unable to Fetch Profile"),
+ NO_PROFILE_FOUND("GVS-422-002","No Profile Found");
+
+ private String code;
+ private String message;
+
+ ErrorCode422(String code, String message) {
+ this.code = code;
+ this.message = message;
+ }
+
+ public String getCode() {
+ return code;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/enums/ErrorCode500.java b/src/main/java/org/upsmf/grievance/enums/ErrorCode500.java
new file mode 100755
index 0000000000000000000000000000000000000000..18492648a3b37c0624dcd96b2b7dbec439dd621c
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/enums/ErrorCode500.java
@@ -0,0 +1,23 @@
+package org.upsmf.grievance.enums;
+
+public enum ErrorCode500 {
+
+ INTERNAL_SERVER_ERROR("GVS-500-999","Internal Technical Error.");
+
+ private String code;
+ private String message;
+
+ ErrorCode500(String code, String message) {
+ this.code = code;
+ this.message = message;
+ }
+
+ public String getCode() {
+ return code;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+}
+
diff --git a/src/main/java/org/upsmf/grievance/enums/RequesterType.java b/src/main/java/org/upsmf/grievance/enums/RequesterType.java
new file mode 100644
index 0000000000000000000000000000000000000000..92de2018da3c4efc9ce69038d1feb4c09f05e6fd
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/enums/RequesterType.java
@@ -0,0 +1,15 @@
+package org.upsmf.grievance.enums;
+
+public enum RequesterType {
+
+ CANDIDATE(1), INSTITUTE(2), FACULTY(3), OTHERS(4);
+
+ private int id;
+ RequesterType(int id) {
+ this.id = id;
+ }
+
+ public int getId() {
+ return id;
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/enums/TicketPriority.java b/src/main/java/org/upsmf/grievance/enums/TicketPriority.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f03727e12373e35c989197cc0cc9c4bf2a64173
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/enums/TicketPriority.java
@@ -0,0 +1,13 @@
+package org.upsmf.grievance.enums;
+
+public enum TicketPriority {
+
+ HIGH(1), MEDIUM(2), LOW(3);
+
+ private int id;
+
+
+ TicketPriority(int id) {
+ this.id = id;
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/enums/TicketStatus.java b/src/main/java/org/upsmf/grievance/enums/TicketStatus.java
new file mode 100644
index 0000000000000000000000000000000000000000..8037f4eb414c590e04b3cbfa9cd9388122080bc9
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/enums/TicketStatus.java
@@ -0,0 +1,12 @@
+package org.upsmf.grievance.enums;
+
+public enum TicketStatus {
+
+ OPEN(1), CLOSED(2);
+
+ private int id;
+
+ TicketStatus(int id) {
+ this.id = id;
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/exception/controller/ExceptionHandler4xxController.java b/src/main/java/org/upsmf/grievance/exception/controller/ExceptionHandler4xxController.java
new file mode 100644
index 0000000000000000000000000000000000000000..04cfd2275ca101cac7116971aee0061b01868bdf
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/exception/controller/ExceptionHandler4xxController.java
@@ -0,0 +1,24 @@
+package org.upsmf.grievance.exception.controller;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.upsmf.grievance.dto.ErrorResponseDto;
+import org.upsmf.grievance.exception.runtime.InvalidRequestException;
+
+@ControllerAdvice
+public class ExceptionHandler4xxController {
+
+ /**
+ * Exception handler for Invalid request exception
+ * @param e
+ * @return
+ */
+ @ExceptionHandler(value = InvalidRequestException.class)
+ @ResponseStatus(HttpStatus.BAD_REQUEST)
+ public ErrorResponseDto handleInvalidRequestException(InvalidRequestException e) {
+ return new ErrorResponseDto(HttpStatus.BAD_REQUEST.value(), e.getMessage());
+ }
+
+}
diff --git a/src/main/java/org/upsmf/grievance/exception/runtime/InvalidRequestException.java b/src/main/java/org/upsmf/grievance/exception/runtime/InvalidRequestException.java
new file mode 100644
index 0000000000000000000000000000000000000000..88546852c0822a4e776ed04c2ddc94d5f2c74e62
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/exception/runtime/InvalidRequestException.java
@@ -0,0 +1,14 @@
+package org.upsmf.grievance.exception.runtime;
+
+public class InvalidRequestException extends RuntimeException {
+
+ private String message;
+
+ public InvalidRequestException() {
+ }
+
+ public InvalidRequestException(String msg) {
+ super(msg);
+ this.message = msg;
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/model/AssigneeTicketAttachment.java b/src/main/java/org/upsmf/grievance/model/AssigneeTicketAttachment.java
new file mode 100644
index 0000000000000000000000000000000000000000..98c90cf51ac22f784f5a225ea0d5e691a2665d35
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/AssigneeTicketAttachment.java
@@ -0,0 +1,28 @@
+package org.upsmf.grievance.model;
+
+import lombok.*;
+
+import javax.persistence.*;
+
+@Entity
+@Table(name ="ticket_assignee_attachment")
+@Data
+@Builder
+@ToString
+@AllArgsConstructor
+@NoArgsConstructor
+public class AssigneeTicketAttachment {
+
+ @Id()
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(name = "ticket_id")
+ private Long ticketId;
+
+ @Column(name = "user_id", nullable = false)
+ private Long userId;
+
+ @Column(name = "attachment_url", nullable = false)
+ private String attachment_url;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/Comments.java b/src/main/java/org/upsmf/grievance/model/Comments.java
new file mode 100644
index 0000000000000000000000000000000000000000..120a715aecd376e39b341b11c0f3242880135598
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/Comments.java
@@ -0,0 +1,28 @@
+package org.upsmf.grievance.model;
+
+import lombok.*;
+
+import javax.persistence.*;
+
+@Entity
+@Table(name ="ticket_comments")
+@Data
+@Builder
+@ToString
+@AllArgsConstructor
+@NoArgsConstructor
+public class Comments {
+
+ @Id()
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(name = "ticket_id", nullable = false)
+ private Long ticketId;
+
+ @Column(name = "user_id", nullable = false)
+ private Long userId;
+
+ @Column(name = "comment", nullable = false)
+ private String comment;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/EmailDetails.java b/src/main/java/org/upsmf/grievance/model/EmailDetails.java
new file mode 100644
index 0000000000000000000000000000000000000000..c09ef12e6a874baa2d960b2e07150c52e5d82106
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/EmailDetails.java
@@ -0,0 +1,16 @@
+package org.upsmf.grievance.model;
+
+import lombok.*;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+@ToString
+public class EmailDetails {
+
+ private String recipient;
+ private String msgBody;
+ private String subject;
+ private String attachment;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/OtpRequest.java b/src/main/java/org/upsmf/grievance/model/OtpRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a57821eba6cd55e0e72be67afcf54cfb5ca5f01a
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/OtpRequest.java
@@ -0,0 +1,16 @@
+package org.upsmf.grievance.model;
+
+import lombok.*;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString(includeFieldNames = true)
+public class OtpRequest {
+
+ private String email;
+ private String phone;
+ private String name;
+
+}
diff --git a/src/main/java/org/upsmf/grievance/model/OtpValidationRequest.java b/src/main/java/org/upsmf/grievance/model/OtpValidationRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..92093c2b3896c21bfa13bd01f93197753e966255
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/OtpValidationRequest.java
@@ -0,0 +1,15 @@
+package org.upsmf.grievance.model;
+
+
+import lombok.*;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString(includeFieldNames = true)
+public class OtpValidationRequest {
+
+ private String email;
+ private String otp;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/RaiserTicketAttachment.java b/src/main/java/org/upsmf/grievance/model/RaiserTicketAttachment.java
new file mode 100644
index 0000000000000000000000000000000000000000..1130b1406488f59a904c52dd265d1f12362c79bd
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/RaiserTicketAttachment.java
@@ -0,0 +1,25 @@
+package org.upsmf.grievance.model;
+
+import lombok.*;
+
+import javax.persistence.*;
+
+@Entity
+@Table(name ="ticket_raiser_attachments")
+@Data
+@Builder
+@ToString
+@AllArgsConstructor
+@NoArgsConstructor
+public class RaiserTicketAttachment {
+
+ @Id()
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(name = "ticket_id", nullable = false)
+ private Long ticketId;
+
+ @Column(name = "attachment_url", nullable = false)
+ private String attachment_url;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/RedisTicketData.java b/src/main/java/org/upsmf/grievance/model/RedisTicketData.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef8858418fa3dc6c5bb558e4f57edab36d4bd3f4
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/RedisTicketData.java
@@ -0,0 +1,24 @@
+package org.upsmf.grievance.model;
+
+import lombok.*;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString(includeFieldNames = true)
+public class RedisTicketData {
+
+ private String email;
+ private Long ticketId;
+
+ private String date;
+
+ private String emailOtp;
+
+ private String mobileOtp;
+
+ private String phoneNumber;
+
+
+}
diff --git a/src/main/java/org/upsmf/grievance/model/Ticket.java b/src/main/java/org/upsmf/grievance/model/Ticket.java
new file mode 100644
index 0000000000000000000000000000000000000000..5df9cdc74860c8bb9296ee165982e9ca67359daa
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/Ticket.java
@@ -0,0 +1,94 @@
+package org.upsmf.grievance.model;
+
+import lombok.*;
+import org.hibernate.annotations.Fetch;
+import org.hibernate.annotations.FetchMode;
+import org.upsmf.grievance.enums.RequesterType;
+import org.upsmf.grievance.enums.TicketPriority;
+import org.upsmf.grievance.enums.TicketStatus;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+import java.util.List;
+
+@Entity
+@Table(name = "ticket")
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+@ToString
+public class Ticket {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.AUTO)
+ private Long id;
+
+ @Column(name = "requester_first_name")
+ private String firstName;
+
+ @Column(name = "requester_last_name")
+ private String lastName;
+
+ @Column(name = "requester_phone")
+ private String phone;
+
+ @Column(name = "requester_email")
+ private String email;
+
+ @Column(name = "requester_type")
+ private RequesterType requesterType;
+
+ @Column(name = "assigned_to_id")
+ private Long assignedToId;
+
+ @Column(name = "description")
+ private String description;
+
+ @Column(name = "is_junk")
+ private boolean junk = false;
+
+ @Column(name = "created_date")
+ private Timestamp createdDate;
+
+ @Column(name = "updated_date")
+ private Timestamp updatedDate;
+
+ @Column(name = "last_updated_by")
+ private Long lastUpdatedBy;
+
+ @Column(name = "is_escalated")
+ private boolean escalated;
+
+ @Column(name = "escalated_date")
+ private Timestamp escalatedDate;
+
+ @Column(name = "escalated_to")
+ private Long escalatedTo;
+
+ @Column(name = "status")
+ private TicketStatus status = TicketStatus.OPEN;
+
+ @Column(name = "request_type")
+ private String requestType;
+
+ @Column(name = "priority")
+ private TicketPriority priority = TicketPriority.LOW;
+
+ // if the ticket is escalated by system, value will be -1 else superAdmin ID
+ @Column(name = "escalated_by")
+ private Long escalatedBy = -1L;
+
+ @OneToMany(targetEntity = Comments.class, mappedBy = "ticketId", fetch = FetchType.EAGER)
+ @Fetch(value = FetchMode.SUBSELECT)
+ private List<Comments> comments;
+
+ @OneToMany(targetEntity = RaiserTicketAttachment.class, mappedBy = "ticketId", fetch = FetchType.EAGER)
+ @Fetch(value = FetchMode.SUBSELECT)
+ private List<RaiserTicketAttachment> raiserTicketAttachmentURLs;
+
+ @OneToMany(targetEntity = AssigneeTicketAttachment.class, mappedBy = "ticketId", fetch = FetchType.EAGER)
+ @Fetch(value = FetchMode.SUBSELECT)
+ private List<AssigneeTicketAttachment> assigneeTicketAttachment;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/es/Feedback.java b/src/main/java/org/upsmf/grievance/model/es/Feedback.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c4c2aa572bfa613606d5ee9bd01e3c53072fe84
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/es/Feedback.java
@@ -0,0 +1,37 @@
+package org.upsmf.grievance.model.es;
+
+import lombok.*;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.elasticsearch.annotations.Document;
+import org.springframework.data.elasticsearch.annotations.Field;
+
+@Document(indexName = "feedback")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@ToString
+public class Feedback {
+
+ @Id
+ private Long id;
+
+ @Field(name = "first_name")
+ private String firstName;
+
+ @Field(name = "last_name")
+ private String lastName;
+
+ @Field(name = "phone")
+ private String phone;
+
+ @Field(name = "email")
+ private String email;
+
+ @Field(name = "rating")
+ private Integer rating;
+
+ @Field(name = "comment")
+ private String comment;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/es/Ticket.java b/src/main/java/org/upsmf/grievance/model/es/Ticket.java
new file mode 100644
index 0000000000000000000000000000000000000000..af1d1930d2f5fa6dcbfefba6b62bd3510d2ed53c
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/es/Ticket.java
@@ -0,0 +1,102 @@
+package org.upsmf.grievance.model.es;
+
+import lombok.*;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.elasticsearch.annotations.Document;
+import org.springframework.data.elasticsearch.annotations.Field;
+import org.upsmf.grievance.enums.RequesterType;
+import org.upsmf.grievance.enums.TicketPriority;
+import org.upsmf.grievance.enums.TicketStatus;
+
+@Document(indexName = "ticket", createIndex = false)
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+@ToString(includeFieldNames = true)
+public class Ticket {
+
+ @Id
+ private String id;
+
+ @Field(name = "ticket_id")
+ private Long ticketId;
+
+ @Field(name = "requester_first_name")
+ private String firstName;
+
+ @Field(name = "requester_last_name")
+ private String lastName;
+
+ @Field(name = "requester_phone")
+ private String phone;
+
+ @Field(name = "requester_email")
+ private String email;
+
+ @Field(name = "requester_type")
+ private RequesterType requesterType;
+
+ @Field(name = "assigned_to_id")
+ private Long assignedToId;
+
+ @Field(name = "assigned_to_name")
+ private String assignedToName;
+
+ @Field(name = "description")
+ private String description;
+
+ @Field(name = "is_junk")
+ private Boolean junk = false;
+
+ @Field(name = "created_date")
+ private String createdDate;
+
+ @Field(name = "updated_date")
+ private String updatedDate;
+
+ @Field(name = "created_date_ts")
+ private Long createdDateTS;
+
+ @Field(name = "updated_date_ts")
+ private Long updatedDateTS;
+
+ @Field(name = "last_updated_by")
+ private Long lastUpdatedBy;
+
+ @Field(name = "is_escalated")
+ private Boolean escalated;
+
+ @Field(name = "escalated_date")
+ private String escalatedDate;
+
+ @Field(name = "escalated_date_ts")
+ private Long escalatedDateTS;
+
+ @Field(name = "escalated_to")
+ private Long escalatedTo;
+
+ @Field(name = "status")
+ private TicketStatus status = TicketStatus.OPEN;
+
+ @Field(name = "request_type")
+ private String requestType;
+
+ @Field(name = "priority")
+ private TicketPriority priority = TicketPriority.LOW;
+
+ // if the ticket is escalated by system, value will be -1 else superAdmin ID
+ @Field(name = "escalated_by")
+ private Long escalatedBy = -1L;
+
+ /* @Field(name = "comments")
+ private List<Comments> comments;
+
+ @Field(name = "raiser_attachment_urls")
+ private String raiserAttachmentURLs;
+
+ @Field(name = "assignee_attachment_urls")
+ private String assigneeAttachmentURLs;*/
+
+}
diff --git a/src/main/java/org/upsmf/grievance/model/reponse/FeedbackResponse.java b/src/main/java/org/upsmf/grievance/model/reponse/FeedbackResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..f42339bf64ae2d618eb5d40ab27545034dc4f882
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/reponse/FeedbackResponse.java
@@ -0,0 +1,15 @@
+package org.upsmf.grievance.model.reponse;
+
+import lombok.Builder;
+import lombok.Data;
+import org.upsmf.grievance.model.es.Feedback;
+
+import java.util.List;
+
+@Data
+@Builder
+public class FeedbackResponse {
+
+ private int count;
+ private List<Feedback> data;
+}
diff --git a/src/main/java/org/upsmf/grievance/model/reponse/Response.java b/src/main/java/org/upsmf/grievance/model/reponse/Response.java
new file mode 100644
index 0000000000000000000000000000000000000000..480ebd1aa8c1116072603773d4843d37f15d0c19
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/reponse/Response.java
@@ -0,0 +1,14 @@
+package org.upsmf.grievance.model.reponse;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class Response {
+
+ private int status;
+
+ private Object body;
+
+}
diff --git a/src/main/java/org/upsmf/grievance/model/reponse/TicketResponse.java b/src/main/java/org/upsmf/grievance/model/reponse/TicketResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..3cb19c90ba51dfe8d6bbbd0e3840041587d090d4
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/model/reponse/TicketResponse.java
@@ -0,0 +1,14 @@
+package org.upsmf.grievance.model.reponse;
+
+import lombok.Builder;
+import lombok.Data;
+import org.upsmf.grievance.model.es.Ticket;
+
+import java.util.List;
+
+@Builder
+@Data
+public class TicketResponse {
+ private List<Ticket> data;
+ private Long count;
+}
diff --git a/src/main/java/org/upsmf/grievance/repository/.DS_Store b/src/main/java/org/upsmf/grievance/repository/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..8d7d653c8e24dace65cf6ca705aa80970795e4ab
Binary files /dev/null and b/src/main/java/org/upsmf/grievance/repository/.DS_Store differ
diff --git a/src/main/java/org/upsmf/grievance/repository/AssigneeTicketAttachmentRepository.java b/src/main/java/org/upsmf/grievance/repository/AssigneeTicketAttachmentRepository.java
new file mode 100644
index 0000000000000000000000000000000000000000..987d2954d81d0a15bfa64c461cf1228635baecd5
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/repository/AssigneeTicketAttachmentRepository.java
@@ -0,0 +1,9 @@
+package org.upsmf.grievance.repository;
+
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+import org.upsmf.grievance.model.AssigneeTicketAttachment;
+
+@Repository
+public interface AssigneeTicketAttachmentRepository extends CrudRepository<AssigneeTicketAttachment, Long> {
+}
diff --git a/src/main/java/org/upsmf/grievance/repository/CommentRepository.java b/src/main/java/org/upsmf/grievance/repository/CommentRepository.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1e1e2409cb1e65d0b01f12a40ce33e52bf65dfa
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/repository/CommentRepository.java
@@ -0,0 +1,9 @@
+package org.upsmf.grievance.repository;
+
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+import org.upsmf.grievance.model.Comments;
+
+@Repository
+public interface CommentRepository extends CrudRepository<Comments, Long> {
+}
diff --git a/src/main/java/org/upsmf/grievance/repository/RaiserTicketAttachmentRepository.java b/src/main/java/org/upsmf/grievance/repository/RaiserTicketAttachmentRepository.java
new file mode 100644
index 0000000000000000000000000000000000000000..04e73901330094a2075665a8399b28210da68019
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/repository/RaiserTicketAttachmentRepository.java
@@ -0,0 +1,9 @@
+package org.upsmf.grievance.repository;
+
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+import org.upsmf.grievance.model.RaiserTicketAttachment;
+
+@Repository
+public interface RaiserTicketAttachmentRepository extends CrudRepository<RaiserTicketAttachment, Long> {
+}
diff --git a/src/main/java/org/upsmf/grievance/repository/TicketRepository.java b/src/main/java/org/upsmf/grievance/repository/TicketRepository.java
new file mode 100644
index 0000000000000000000000000000000000000000..84fd518e6dc43bf6435791489b92898c6ae375b1
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/repository/TicketRepository.java
@@ -0,0 +1,9 @@
+package org.upsmf.grievance.repository;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository("ticketRepository")
+public interface TicketRepository extends CrudRepository<org.upsmf.grievance.model.Ticket, Long> {
+}
diff --git a/src/main/java/org/upsmf/grievance/repository/es/FeedbackRepository.java b/src/main/java/org/upsmf/grievance/repository/es/FeedbackRepository.java
new file mode 100644
index 0000000000000000000000000000000000000000..e17dc1724bd823819cc68dca47ac0a39922e41a0
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/repository/es/FeedbackRepository.java
@@ -0,0 +1,9 @@
+package org.upsmf.grievance.repository.es;
+
+import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
+import org.springframework.stereotype.Repository;
+import org.upsmf.grievance.model.es.Feedback;
+
+@Repository
+public interface FeedbackRepository extends ElasticsearchRepository<Feedback, String> {
+}
diff --git a/src/main/java/org/upsmf/grievance/repository/es/TicketRepository.java b/src/main/java/org/upsmf/grievance/repository/es/TicketRepository.java
new file mode 100644
index 0000000000000000000000000000000000000000..8423330e6a43d2f758f1b67fc9dfaec8930d3372
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/repository/es/TicketRepository.java
@@ -0,0 +1,16 @@
+package org.upsmf.grievance.repository.es;
+
+import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+import org.upsmf.grievance.model.es.Ticket;
+
+import java.util.Optional;
+
+@Repository("esTicketRepository")
+public interface TicketRepository extends ElasticsearchRepository<Ticket, String> {
+ @Query("{'ticket_id': ?0}")
+ Optional<Ticket> findOneByTicketId(long id);
+
+
+}
diff --git a/src/main/java/org/upsmf/grievance/service/.DS_Store b/src/main/java/org/upsmf/grievance/service/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..00b0945c8fb3b31bf223c60f5862a024f4d47ee8
Binary files /dev/null and b/src/main/java/org/upsmf/grievance/service/.DS_Store differ
diff --git a/src/main/java/org/upsmf/grievance/service/AttachmentService.java b/src/main/java/org/upsmf/grievance/service/AttachmentService.java
new file mode 100644
index 0000000000000000000000000000000000000000..141c62828181df0b10de8b31dcc6ca820c0026df
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/AttachmentService.java
@@ -0,0 +1,10 @@
+package org.upsmf.grievance.service;
+
+import org.upsmf.grievance.dto.FileUploadRequest;
+
+import java.io.IOException;
+
+public interface AttachmentService {
+
+ void uploadObject(FileUploadRequest fileUploadRequest);
+}
diff --git a/src/main/java/org/upsmf/grievance/service/EmailService.java b/src/main/java/org/upsmf/grievance/service/EmailService.java
new file mode 100644
index 0000000000000000000000000000000000000000..715ae337ba5ce65b5ab0894e13c98a934f6a6dc9
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/EmailService.java
@@ -0,0 +1,14 @@
+package org.upsmf.grievance.service;
+
+import org.upsmf.grievance.model.EmailDetails;
+
+public interface EmailService {
+
+ // Method
+ // To send a simple email
+ void sendSimpleMail(EmailDetails details);
+
+ // Method
+ // To send an email with attachment
+ void sendMailWithAttachment(EmailDetails details);
+}
diff --git a/src/main/java/org/upsmf/grievance/service/FeedbackService.java b/src/main/java/org/upsmf/grievance/service/FeedbackService.java
new file mode 100644
index 0000000000000000000000000000000000000000..dedb90ff2eae9de276012013108d4127dc40b682
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/FeedbackService.java
@@ -0,0 +1,11 @@
+package org.upsmf.grievance.service;
+
+import org.upsmf.grievance.dto.FeedbackDto;
+import org.upsmf.grievance.model.reponse.FeedbackResponse;
+
+public interface FeedbackService {
+
+ public void saveFeedback(FeedbackDto feedbackDto);
+
+ public FeedbackResponse getFeedbacks();
+}
diff --git a/src/main/java/org/upsmf/grievance/service/OtpService.java b/src/main/java/org/upsmf/grievance/service/OtpService.java
new file mode 100644
index 0000000000000000000000000000000000000000..0758d6125af46b77bf8e922df8705c10155a8367
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/OtpService.java
@@ -0,0 +1,12 @@
+package org.upsmf.grievance.service;
+
+import org.springframework.stereotype.Service;
+import org.upsmf.grievance.model.OtpRequest;
+
+@Service
+public interface OtpService {
+
+ String generateAndSendOtp(OtpRequest otpRequest);
+ boolean validateOtp(String email, String otp);
+ void sendGenericEmail(String email, String subject, String mailBody);
+}
diff --git a/src/main/java/org/upsmf/grievance/service/SearchService.java b/src/main/java/org/upsmf/grievance/service/SearchService.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ff264eeedc78f4f6053ab340890782ef0241200
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/SearchService.java
@@ -0,0 +1,11 @@
+package org.upsmf.grievance.service;
+
+import org.upsmf.grievance.model.es.Ticket;
+import org.upsmf.grievance.dto.SearchRequest;
+import org.upsmf.grievance.model.reponse.TicketResponse;
+
+import java.util.Optional;
+
+public interface SearchService {
+ TicketResponse search(SearchRequest searchRequest);
+}
\ No newline at end of file
diff --git a/src/main/java/org/upsmf/grievance/service/TicketService.java b/src/main/java/org/upsmf/grievance/service/TicketService.java
new file mode 100644
index 0000000000000000000000000000000000000000..11884f93c14b911c2189627dbe891c7f12771ae5
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/TicketService.java
@@ -0,0 +1,16 @@
+package org.upsmf.grievance.service;
+
+import org.upsmf.grievance.model.Ticket;
+import org.upsmf.grievance.dto.TicketRequest;
+import org.upsmf.grievance.dto.UpdateTicketRequest;
+
+public interface TicketService {
+
+ Ticket save(Ticket ticket);
+
+ Ticket save(TicketRequest ticketRequest) throws Exception;
+
+ Ticket update(UpdateTicketRequest updateTicketRequest);
+
+ Ticket getTicketById(long id);
+}
diff --git a/src/main/java/org/upsmf/grievance/service/impl/.DS_Store b/src/main/java/org/upsmf/grievance/service/impl/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
Binary files /dev/null and b/src/main/java/org/upsmf/grievance/service/impl/.DS_Store differ
diff --git a/src/main/java/org/upsmf/grievance/service/impl/AttachmentServiceImpl.java b/src/main/java/org/upsmf/grievance/service/impl/AttachmentServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d4636b52f4416bb2fb76b46695bafcb0885a0e8
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/impl/AttachmentServiceImpl.java
@@ -0,0 +1,65 @@
+package org.upsmf.grievance.service.impl;
+
+import com.google.auth.oauth2.ServiceAccountCredentials;
+import com.google.cloud.storage.*;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.upsmf.grievance.dto.FileUploadRequest;
+import org.upsmf.grievance.service.AttachmentService;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@Service
+@Slf4j
+public class AttachmentServiceImpl implements AttachmentService {
+
+ @Value("${gcp.config.file.path}")
+ private String gcpConfigFilePath;
+
+ @Value("${gcp.bucket.name}")
+ private String gcpBucketName;
+
+ @Value("${gcp.bucket.folder.name}")
+ private String gcpFolderName;
+
+ @Value("${gcp.max.file.size}")
+ private String gcpMaxFileSize;
+
+ @Value("${gcp.project.id}")
+ private String gcpProjectId;
+
+ @Value("${gcp.client.id}")
+ private String gcpClientId;
+
+ @Value("${gcp.client.email}")
+ private String gcpClientEmail;
+
+ @Value("${gcp.pkcs.key}")
+ private String gcpPkcsKey;
+
+ @Value("${gcp.private.key.id}")
+ private String gcpPrivateKeyId;
+
+ @Override
+ public void uploadObject(FileUploadRequest fileUploadRequest) {
+ try {
+ Path filePath = Files.createTempFile(fileUploadRequest.getFileName().split(".")[0], fileUploadRequest.getFileName().split(".")[1]);
+ ServiceAccountCredentials credentials = ServiceAccountCredentials.fromPkcs8(gcpClientId, gcpClientEmail,
+ gcpPkcsKey, gcpPrivateKeyId, new java.util.ArrayList<String>());
+ System.out.println("credentials created");
+ Storage storage = StorageOptions.newBuilder().setProjectId(gcpProjectId).setCredentials(credentials).build().getService();
+ System.out.println("storage object created");
+ BlobId blobId = BlobId.of(gcpBucketName, fileUploadRequest.getFileName());
+ BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
+ Blob blob = storage.createFrom(blobInfo, filePath);
+ // TODO return correct response after testing
+ System.out.println(blob);
+ } catch (IOException e) {
+ log.error("Error while uploading attachment", e);
+ }
+ }
+
+}
diff --git a/src/main/java/org/upsmf/grievance/service/impl/EmailServiceImpl.java b/src/main/java/org/upsmf/grievance/service/impl/EmailServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..154b1d8af915030c263a48dda52c82b06609dc93
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/impl/EmailServiceImpl.java
@@ -0,0 +1,82 @@
+package org.upsmf.grievance.service.impl;
+
+// Importing required classes
+import java.io.File;
+import javax.mail.MessagingException;
+import javax.mail.internet.MimeMessage;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.io.FileSystemResource;
+import org.springframework.mail.SimpleMailMessage;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.mail.javamail.MimeMessageHelper;
+import org.springframework.stereotype.Service;
+import org.upsmf.grievance.model.EmailDetails;
+import org.upsmf.grievance.service.EmailService;
+
+// Annotation
+@Service
+@Slf4j
+// Class
+// Implementing EmailService interface
+public class EmailServiceImpl implements EmailService {
+
+ @Autowired private JavaMailSender javaMailSender;
+
+ @Value("${spring.mail.username}") private String sender;
+
+ // Method 1
+ // To send a simple email
+ @Override
+ public void sendSimpleMail(EmailDetails details)
+ {
+ // Try block to check for exceptions
+ try {
+ // Creating a simple mail message
+ SimpleMailMessage mailMessage = new SimpleMailMessage();
+ // Setting up necessary details
+ mailMessage.setFrom(sender);
+ mailMessage.setTo(details.getRecipient());
+ mailMessage.setText(details.getMsgBody());
+ mailMessage.setSubject(details.getSubject());
+ // Sending the mail
+ javaMailSender.send(mailMessage);
+ log.info("Mail Sent Successfully...");
+ }
+ // Catch block to handle the exceptions
+ catch (Exception e) {
+ log.error("Error while Sending Mail", e);
+ }
+ }
+
+ // Method 2
+ // To send an email with attachment
+ @Override
+ public void sendMailWithAttachment(EmailDetails details)
+ {
+ // Creating a mime message
+ MimeMessage mimeMessage = javaMailSender.createMimeMessage();
+ MimeMessageHelper mimeMessageHelper;
+ try {
+ // Setting multipart as true for attachments tobe send
+ mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
+ mimeMessageHelper.setFrom(sender);
+ mimeMessageHelper.setTo(details.getRecipient());
+ mimeMessageHelper.setText(details.getMsgBody());
+ mimeMessageHelper.setSubject(details.getSubject());
+ // Adding the attachment
+ FileSystemResource file = new FileSystemResource(new File(details.getAttachment()));
+ mimeMessageHelper.addAttachment(file.getFilename(), file);
+ // Sending the mail
+ javaMailSender.send(mimeMessage);
+ log.info("Mail Sent Successfully...");
+ }
+ // Catch block to handle MessagingException
+ catch (MessagingException e) {
+ // Display message when exception occurred
+ log.error("Error while Sending Mail with attachment", e);
+ }
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/service/impl/FeedbackServiceImpl.java b/src/main/java/org/upsmf/grievance/service/impl/FeedbackServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..50e5479961cf0771bcb866da9842076982826b10
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/impl/FeedbackServiceImpl.java
@@ -0,0 +1,41 @@
+package org.upsmf.grievance.service.impl;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.upsmf.grievance.dto.FeedbackDto;
+import org.upsmf.grievance.model.es.Feedback;
+import org.upsmf.grievance.model.reponse.FeedbackResponse;
+import org.upsmf.grievance.repository.es.FeedbackRepository;
+import org.upsmf.grievance.service.FeedbackService;
+
+@Service
+public class FeedbackServiceImpl implements FeedbackService {
+
+ @Value("${es.default.page.size}")
+ private int defaultPageSize;
+
+ @Autowired
+ private FeedbackRepository feedbackRepository;
+
+ @Override
+ public void saveFeedback(FeedbackDto feedbackDto) {
+ // TODO validate request -- all fields are mandatory except comment
+ Feedback feedback = Feedback.builder()
+ .firstName(feedbackDto.getFirstName())
+ .lastName(feedbackDto.getLastName())
+ .email(feedbackDto.getEmail())
+ .phone(feedbackDto.getPhone())
+ .rating(feedbackDto.getRating())
+ .comment(feedbackDto.getComment()!=null?feedbackDto.getComment():"").build();
+ feedbackRepository.save(feedback);
+ }
+
+ @Override
+ public FeedbackResponse getFeedbacks() {
+ Page<Feedback> page = feedbackRepository.findAll(Pageable.ofSize(defaultPageSize));
+ return FeedbackResponse.builder().count(page.getNumberOfElements()).data(page.getContent()).build();
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/service/impl/OtpServiceImpl.java b/src/main/java/org/upsmf/grievance/service/impl/OtpServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0ee6bba9bb695ab0bf74572985162abfbdf0dc6
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/impl/OtpServiceImpl.java
@@ -0,0 +1,117 @@
+package org.upsmf.grievance.service.impl;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.mail.SimpleMailMessage;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.stereotype.Service;
+import org.upsmf.grievance.model.OtpRequest;
+import org.upsmf.grievance.model.RedisTicketData;
+import org.upsmf.grievance.service.OtpService;
+
+import java.util.concurrent.TimeUnit;
+
+@Service(value = "OtpService")
+public class OtpServiceImpl implements OtpService {
+
+ @Autowired
+ private StringRedisTemplate redisTemplate;
+
+ @Autowired
+ private JavaMailSender mailSender;
+
+ @Value("${otp.expiration.minutes}")
+ private int otpExpirationMinutes;
+
+ @Autowired
+ public OtpServiceImpl(StringRedisTemplate redisTemplate, JavaMailSender mailSender) {
+ this.redisTemplate = redisTemplate;
+ this.mailSender = mailSender;
+ }
+
+ @Override
+ public String generateAndSendOtp(OtpRequest otpRequest) {
+ String email = otpRequest.getEmail();
+ String otp = generateOtp();
+ String mobileOtp= generateOtp();
+ RedisTicketData redisTicketData = new RedisTicketData();
+ redisTicketData.setEmail(email);
+ redisTicketData.setPhoneNumber(otpRequest.getPhone());
+ redisTicketData.setEmailOtp(otp);
+ redisTicketData.setMobileOtp(mobileOtp);
+
+ String redisKey = "otp:" + email;
+ redisTemplate.opsForValue().set(redisKey, toJson(redisTicketData), otpExpirationMinutes, TimeUnit.MINUTES);
+
+ sendOtpEmail(email, otp);
+ return otp;
+ }
+
+ @Override
+ public boolean validateOtp(String email, String enteredOtp) {
+ String redisKey = "otp:" + email;
+ String redisData = redisTemplate.opsForValue().get(redisKey);
+ if (redisData != null) {
+ RedisTicketData ticketData = fromJson(redisData, RedisTicketData.class);
+ if (ticketData.getEmailOtp().equals(enteredOtp)) {
+ // Remove the data from Redis after successful validation
+ redisTemplate.delete(redisKey);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private String toJson(Object obj) {
+ try {
+ ObjectMapper objectMapper = new ObjectMapper();
+ return objectMapper.writeValueAsString(obj);
+ } catch (JsonProcessingException e) {
+ // Handle the exception
+ return null;
+ }
+ }
+
+ private <T> T fromJson(String json, Class<T> valueType) {
+ try {
+ ObjectMapper objectMapper = new ObjectMapper();
+ return objectMapper.readValue(json, valueType);
+ } catch (JsonProcessingException e) {
+ // Handle the exception
+ return null;
+ }
+ }
+
+
+ private String generateOtp() {
+ int otpLength = 6;
+ StringBuilder otp = new StringBuilder();
+
+ for (int i = 0; i < otpLength; i++) {
+ int digit = (int) (Math.random() * 10);
+ otp.append(digit);
+ }
+
+ return otp.toString();
+ }
+
+ private void sendOtpEmail(String email, String otp) {
+ SimpleMailMessage message = new SimpleMailMessage();
+ message.setTo(email);
+ message.setSubject("Your OTP for Ticket Creation");
+ message.setText("Your OTP is: " + otp);
+ mailSender.send(message);
+ }
+
+ @Override
+ public void sendGenericEmail(String email, String subject, String mailBody) {
+ SimpleMailMessage message = new SimpleMailMessage();
+ message.setTo(email);
+ message.setSubject(subject);
+ message.setText(mailBody);
+ mailSender.send(message);
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/service/impl/SearchServiceImpl.java b/src/main/java/org/upsmf/grievance/service/impl/SearchServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..3439b8d5fa6b47e93ec0810fc14cb390f5709a61
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/impl/SearchServiceImpl.java
@@ -0,0 +1,36 @@
+package org.upsmf.grievance.service.impl;
+
+import org.elasticsearch.index.query.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
+import org.springframework.data.elasticsearch.core.SearchHits;
+import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
+import org.springframework.data.elasticsearch.core.query.Query;
+import org.springframework.stereotype.Service;
+import org.upsmf.grievance.model.es.Feedback;
+import org.upsmf.grievance.model.es.Ticket;
+import org.upsmf.grievance.dto.SearchRequest;
+import org.upsmf.grievance.model.reponse.TicketResponse;
+import org.upsmf.grievance.repository.es.TicketRepository;
+import org.upsmf.grievance.service.SearchService;
+
+import java.util.Optional;
+
+@Service
+public class SearchServiceImpl implements SearchService {
+
+ @Value("${es.default.page.size}")
+ private int defaultPageSize;
+ @Autowired
+ private TicketRepository esTicketRepository;
+
+ @Override
+ public TicketResponse search(SearchRequest searchRequest) {
+ Page<Ticket> page = esTicketRepository.findAll(Pageable.ofSize(defaultPageSize));
+ return TicketResponse.builder().count(page.getTotalElements()).data(page.getContent()).build();
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/org/upsmf/grievance/service/impl/TicketServiceImpl.java b/src/main/java/org/upsmf/grievance/service/impl/TicketServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..e683f5ba28c4353dc0c920af10e7d7c8761a8c80
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/service/impl/TicketServiceImpl.java
@@ -0,0 +1,275 @@
+package org.upsmf.grievance.service.impl;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.stereotype.Service;
+import org.upsmf.grievance.dto.TicketRequest;
+import org.upsmf.grievance.dto.UpdateTicketRequest;
+import org.upsmf.grievance.enums.TicketPriority;
+import org.upsmf.grievance.enums.TicketStatus;
+import org.upsmf.grievance.model.AssigneeTicketAttachment;
+import org.upsmf.grievance.model.Comments;
+import org.upsmf.grievance.model.RaiserTicketAttachment;
+import org.upsmf.grievance.model.Ticket;
+import org.upsmf.grievance.repository.AssigneeTicketAttachmentRepository;
+import org.upsmf.grievance.repository.CommentRepository;
+import org.upsmf.grievance.repository.RaiserTicketAttachmentRepository;
+import org.upsmf.grievance.repository.es.TicketRepository;
+import org.upsmf.grievance.service.OtpService;
+import org.upsmf.grievance.service.TicketService;
+import org.upsmf.grievance.util.DateUtil;
+
+import javax.transaction.Transactional;
+import java.sql.Timestamp;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class TicketServiceImpl implements TicketService {
+
+ @Autowired
+ @Qualifier("esTicketRepository")
+ private TicketRepository esTicketRepository;
+
+ @Autowired
+ @Qualifier("ticketRepository")
+ private org.upsmf.grievance.repository.TicketRepository ticketRepository;
+
+ @Autowired
+ private CommentRepository commentRepository;
+
+ @Autowired
+ private AssigneeTicketAttachmentRepository assigneeTicketAttachmentRepository;
+
+ @Autowired
+ private RaiserTicketAttachmentRepository raiserTicketAttachmentRepository;
+
+ @Autowired
+ private OtpService otpService;
+
+ /**
+ *
+ * @param ticket
+ * @return
+ */
+ @Transactional
+ public Ticket saveWithAttachment(Ticket ticket, List<String> attachments) {
+ // save ticket in postgres
+ org.upsmf.grievance.model.Ticket psqlTicket = ticketRepository.save(ticket);
+ // update attachments if present
+ if(attachments != null) {
+ for(String url : attachments) {
+ RaiserTicketAttachment raiserTicketAttachment = RaiserTicketAttachment.builder()
+ .attachment_url(url)
+ .ticketId(ticket.getId())
+ .build();
+ raiserTicketAttachmentRepository.save(raiserTicketAttachment);
+ }
+ }
+ // covert to ES ticket object
+ org.upsmf.grievance.model.es.Ticket esticket = convertToESTicketObj(ticket);
+ // save ticket in ES
+ esTicketRepository.save(esticket);
+ // TODO send mail
+ return psqlTicket;
+ }
+
+ @Override
+ @Transactional
+ public Ticket save(Ticket ticket) {
+ // save ticket in postgres
+ org.upsmf.grievance.model.Ticket psqlTicket = ticketRepository.save(ticket);
+ // covert to ES ticket object
+ org.upsmf.grievance.model.es.Ticket esticket = convertToESTicketObj(ticket);
+ // save ticket in ES
+ esTicketRepository.save(esticket);
+ // TODO send mail
+ return psqlTicket;
+ }
+
+ /**
+ *
+ * @param ticketRequest
+ * @return
+ * @throws Exception
+ */
+ @Override
+ @Transactional
+ public Ticket save(TicketRequest ticketRequest) throws Exception {
+ // TODO validate request
+ // validate OTP
+ boolean isValid = otpService.validateOtp(ticketRequest.getEmail(), ticketRequest.getOtp());
+ if(!isValid) {
+ throw new RuntimeException("Bad Request");
+ }
+ // set default value for creating ticket
+ Ticket ticket = createTicketWithDefault(ticketRequest);
+ // create ticket
+ ticket = saveWithAttachment(ticket, ticketRequest.getAttachmentURls());
+ // TODO get email subject and body from db
+ otpService.sendGenericEmail(ticketRequest.getEmail(), "Ticket Created", "You ticket is created with ID "+ticket.getId()+" at "+ticket.getCreatedDate());
+ return ticket;
+ }
+
+ /**
+ *
+ * @param ticketRequest
+ * @return
+ * @throws Exception
+ */
+ private Ticket createTicketWithDefault(TicketRequest ticketRequest) throws Exception {
+ Timestamp currentTimestamp = new Timestamp(DateUtil.getCurrentDate().getTime());
+ return Ticket.builder()
+ .createdDate(new Timestamp(DateUtil.getCurrentDate().getTime()))
+ .firstName(ticketRequest.getFirstName())
+ .lastName(ticketRequest.getLastName())
+ .phone(ticketRequest.getPhone())
+ .email(ticketRequest.getEmail())
+ .requesterType(ticketRequest.getUserType())
+ .assignedToId(ticketRequest.getCc())
+ .description(ticketRequest.getDescription())
+ .createdDate(currentTimestamp)
+ .updatedDate(currentTimestamp)
+ .lastUpdatedBy(-1l)
+ .escalated(false)
+ .escalatedDate(null)
+ .escalatedTo(-1l)
+ .status(TicketStatus.OPEN)
+ .requestType(ticketRequest.getRequestType())
+ .priority(TicketPriority.LOW)
+ .escalatedBy(-1l)
+ .build();
+ }
+
+ /**
+ *
+ * @param updateTicketRequest
+ * @return
+ */
+ @Override
+ @Transactional
+ public Ticket update(UpdateTicketRequest updateTicketRequest) {
+ // TODO validate ticket
+ // check if the ticket exists
+ Optional<Ticket> ticketDetails = getTicketDetailsByID(updateTicketRequest.getId());
+ Ticket ticket = null;
+ if(!ticketDetails.isPresent()) {
+ // TODO throw exception
+ throw new RuntimeException("Ticket does not exists");
+ }
+ ticket = ticketDetails.get();
+ // set incoming values
+ setUpdateTicket(updateTicketRequest, ticket);
+ // update ticket in DB
+ ticketRepository.save(ticket);
+ ticket = getTicketById(ticket.getId());
+ // check if ticket exists in ES
+ Optional<org.upsmf.grievance.model.es.Ticket> esTicketDetails = esTicketRepository.findOneByTicketId(updateTicketRequest.getId());
+ org.upsmf.grievance.model.es.Ticket updatedESTicket = convertToESTicketObj(ticket);
+ if(esTicketDetails.isPresent()) {
+ // TODO revisit this
+ esTicketRepository.deleteById(esTicketDetails.get().getId());
+ }
+ esTicketRepository.save(updatedESTicket);
+ return ticket;
+ }
+
+ @Override
+ public Ticket getTicketById(long id) {
+ if(id <= 0) {
+ throw new RuntimeException("Invalid Ticket ID");
+ }
+ Optional<Ticket> ticketDetails = getTicketDetailsByID(id);
+ if(!ticketDetails.isPresent()) {
+ throw new RuntimeException("Invalid Ticket ID");
+ }
+ return ticketDetails.get();
+ }
+
+ /**
+ *
+ * @param updateTicketRequest
+ * @param ticket
+ */
+ private void setUpdateTicket(UpdateTicketRequest updateTicketRequest, Ticket ticket) {
+ // TODO check request role and permission
+ ticket.setStatus(updateTicketRequest.getStatus());
+ ticket.setAssignedToId(updateTicketRequest.getCc());
+ ticket.setPriority(updateTicketRequest.getPriority());
+ // update assignee comments
+ Comments comments = Comments.builder().comment(updateTicketRequest.getComment())
+ .userId(updateTicketRequest.getRequestedBy())
+ .ticketId(ticket.getId())
+ .build();
+ commentRepository.save(comments);
+ // update assignee attachment url
+ if(updateTicketRequest.getAssigneeAttachmentURLs() != null) {
+ for (String url : updateTicketRequest.getAssigneeAttachmentURLs()) {
+ AssigneeTicketAttachment assigneeTicketAttachment = AssigneeTicketAttachment.builder()
+ .userId(updateTicketRequest.getRequestedBy())
+ .ticketId(ticket.getId())
+ .attachment_url(url).build();
+ assigneeTicketAttachmentRepository.save(assigneeTicketAttachment);
+ }
+ }
+ }
+
+ /**
+ *
+ * @param ticket
+ * @return
+ */
+ private org.upsmf.grievance.model.es.Ticket convertToESTicketObj(Ticket ticket) {
+ DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DateUtil.DEFAULT_DATE_FORMAT);
+ ObjectMapper mapper = new ObjectMapper();
+ // TODO get user details based on ID
+ return org.upsmf.grievance.model.es.Ticket.builder()
+ .ticketId(ticket.getId())
+ .firstName(ticket.getFirstName())
+ .lastName(ticket.getLastName())
+ .phone(ticket.getPhone())
+ .email(ticket.getEmail())
+ .requesterType(ticket.getRequesterType())
+ .assignedToId(ticket.getAssignedToId())
+ .assignedToName("") // get user details based on ID
+ .description(ticket.getDescription())
+ .junk(ticket.isJunk())
+ .createdDate(ticket.getCreatedDate().toLocalDateTime().format(dateTimeFormatter))
+ .createdDateTS(ticket.getCreatedDate().getTime())
+ .updatedDate(ticket.getUpdatedDate().toLocalDateTime().format(dateTimeFormatter))
+ .updatedDateTS(ticket.getUpdatedDate().getTime())
+ .lastUpdatedBy(ticket.getLastUpdatedBy())
+ .escalated(ticket.isEscalated())
+ .escalatedDate(ticket.getEscalatedDate()!=null?ticket.getEscalatedDate().toLocalDateTime().format(dateTimeFormatter):null)
+ .escalatedDateTS(ticket.getEscalatedDate()!=null?ticket.getEscalatedDate().getTime():-1)
+ .status(ticket.getStatus())
+ .requestType(ticket.getRequestType())
+ .priority(ticket.getPriority())
+ .escalatedBy(ticket.getEscalatedBy())
+ .escalatedTo(ticket.getEscalatedTo()).build();
+ //.comments(ticket.getComments()!=null?ticket.getComments():Collections.EMPTY_LIST)
+ //.raiserAttachmentURLs(ticket.getRaiserTicketAttachmentURLs()!=null?mapper.writeValueAsString(ticket.getRaiserTicketAttachmentURLs()):"")
+ //.assigneeAttachmentURLs(ticket.getAssigneeTicketAttachment()!=null?mapper.writeValueAsString(ticket.getAssigneeTicketAttachment()):"").build();
+ }
+
+ /**
+ *
+ * @param id
+ * @return
+ */
+ public Optional<org.upsmf.grievance.model.es.Ticket> getESTicketByID(long id) {
+ return esTicketRepository.findOneByTicketId(id);
+ }
+
+ /**
+ *
+ * @param id
+ * @return
+ */
+ public Optional<Ticket> getTicketDetailsByID(long id) {
+ return ticketRepository.findById(id);
+ }
+}
diff --git a/src/main/java/org/upsmf/grievance/util/DateUtil.java b/src/main/java/org/upsmf/grievance/util/DateUtil.java
new file mode 100644
index 0000000000000000000000000000000000000000..a99a2b212012b6e04d5346f95892b722cfd66854
--- /dev/null
+++ b/src/main/java/org/upsmf/grievance/util/DateUtil.java
@@ -0,0 +1,397 @@
+package org.upsmf.grievance.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.upsmf.grievance.constants.Constants;
+
+import java.sql.Timestamp;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.format.DateTimeFormatter;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.TimeZone;
+
+public class DateUtil {
+
+ private static final String ENCOUNTERED_AN_EXCEPTION = "Encountered an Exception : %s";
+
+ public static final Logger LOGGER = LoggerFactory.getLogger(DateUtil.class);
+
+ public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
+ public static final String INVOICE_DATE_FORMATTER = "EEEE, MMMM d, yyyy";
+ public static final String YYYYMMDD_FORMATTER = "yyyy-MM-dd";
+ public static final String DATE_MONTH_YEAR_FORMAT = "dd-MMMM-yyyy";
+
+ /**
+ * this method take date object and format the date with time zone IST.
+ *
+ * @param date
+ * date object
+ * @return formatted date as String in "yyyy-MM-dd HH:mm:ss"
+ */
+ public static String getFormattedDateInIST(Date date) {
+ SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ format.setTimeZone(TimeZone.getTimeZone(Constants.TIME_ZONE));
+ return format.format(date);
+ }
+
+
+ public static String getFormattedDateInString(Timestamp ts) {
+ DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT);
+ return dateTimeFormatter.format(ts.toLocalDateTime());
+ }
+
+ /**
+ * this method take date object and time zone ,and format date object with
+ * incoming time zone.
+ *
+ * @param date
+ * date object
+ * @param timeZone
+ * @return formatted date as String in "yyyy-MM-dd HH:mm:ss"
+ */
+ public static String getFormattedDateWithTimeZone(Date date, String timeZone) {
+ SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ format.setTimeZone(TimeZone.getTimeZone(timeZone));
+ return format.format(date);
+ }
+
+ /**
+ * this method will format current date object with incoming formatter
+ *
+ * @param format
+ * date formatter
+ * @return String formatted date object.
+ */
+ public static String getCurrentDate(String format) {
+ SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+ return dateFormat.format(new Date());
+ }
+
+ /**
+ * this method will format long time value to given time zone with MM-dd-yyyy
+ * HH:mm:ss
+ *
+ * @param timeZone
+ * @param time
+ * @return String
+ */
+ public static String convertLongToStringAsDateTime(String timeZone, long time) {
+ SimpleDateFormat format = new SimpleDateFormat("MM-dd-yyyy HH:mm:ss");
+ format.setTimeZone(TimeZone.getTimeZone(timeZone));
+ Date date = new Date(time);
+ return format.format(date);
+ }
+
+ /**
+ * this method will format long time value to given time zone with MM-dd-yyyy
+ * HH:mm:ss
+ *
+ * @param timeZone
+ * @param date
+ * @param incomingDateFormat
+ * @return String
+ */
+ public static String dateFormatter(String timeZone, String date, String incomingDateFormat) {
+ SimpleDateFormat format = new SimpleDateFormat("MM-dd-yyyy HH:mm:ss");
+ SimpleDateFormat incomingFormatter = new SimpleDateFormat(incomingDateFormat);
+ incomingFormatter.setTimeZone(TimeZone.getDefault());
+ format.setTimeZone(TimeZone.getTimeZone(timeZone));
+ String response = "";
+ try {
+ Date defaultFormattedDate = incomingFormatter.parse(date);
+ response = format.format(defaultFormattedDate);
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return response;
+ } //
+
+ /**
+ * this method will format long time value to given time zone with MMMMM d
+ * EEEEEEEEE,hh:mm a
+ *
+ * @param timeZone
+ * @param date
+ * @param incomingDateFormat
+ * @return String
+ */
+ public static String ormatterInMMMMdEEE(String timeZone, String date, String incomingDateFormat) {
+ SimpleDateFormat format = new SimpleDateFormat("EEEEEEEEE, MMMMM d @hh:mm a");
+ SimpleDateFormat incomingFormatter = new SimpleDateFormat(incomingDateFormat);
+ incomingFormatter.setTimeZone(TimeZone.getDefault());
+ format.setTimeZone(TimeZone.getTimeZone(timeZone));
+ String response = "";
+ try {
+ Date defaultFormattedDate = incomingFormatter.parse(date);
+ response = format.format(defaultFormattedDate);
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return response;
+ }
+
+ /**
+ * this method will format long time value to given time zone with MMMMM d
+ * EEEEEEEEE,hh:mm a
+ *
+ * @param timeZone
+ * @param time
+ * @return String
+ */
+ public static String convertLongToStringAsMMMMEEEE(String timeZone, long time) {
+ SimpleDateFormat format = new SimpleDateFormat("EEEEEEEEE, MMMMM d @hh:mm a");
+ format.setTimeZone(TimeZone.getTimeZone(timeZone));
+ Date date = new Date(time);
+ return format.format(date);
+ }
+
+ /**
+ * this method will format date object with time zone
+ *
+ * @param date
+ * date object
+ * @param timeZone
+ * String
+ * @return String
+ */
+ public static String getSqlTimeStamp(Date date, String... timeZone) {
+
+ DateFormat format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ if (timeZone != null && timeZone.length > 0) {
+ format.setTimeZone(TimeZone.getTimeZone(timeZone[0]));
+ }
+ return format.format(date);
+ }
+
+ /**
+ * this method will convert long value to date object and provide formatted date
+ * object in "yyyy-MM-dd HH:mm:ss" this form
+ *
+ * @param time
+ * @return String
+ */
+ public static String getSqlTimeStamp(Long time) {
+ return getSqlTimeStamp(new Date(time));
+ }
+
+ /**
+ *
+ * @param date
+ * @param timeZone
+ * @return Date
+ * @throws Exception
+ */
+ public static Date getDateInDefaultTimeZone(String date, String timeZone) throws Exception {
+ SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ SimpleDateFormat formatterWithDefaultTimeZone = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ format.setTimeZone(TimeZone.getTimeZone(timeZone));
+ Date reservationTimeWithTimeZone = format.parse(date + ":00");
+ String reservationTimeWithDefaultTimeZone = formatterWithDefaultTimeZone.format(reservationTimeWithTimeZone);
+ return formatterWithDefaultTimeZone.parse(reservationTimeWithDefaultTimeZone);
+ }
+
+ /**
+ *
+ * @return Date
+ * @throws Exception
+ */
+ public static Date getCurrentDate() throws Exception {
+ SimpleDateFormat formatterWithDefaultTimeZone = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ Date currDate = new Date();
+ String currTimeWithTimeZone = formatterWithDefaultTimeZone.format(currDate);
+ return formatterWithDefaultTimeZone.parse(currTimeWithTimeZone);
+ }
+
+ /**
+ * This method will convert String date time with IST time Zone in "yyyy-MM-dd
+ * HH:mm:ss" format
+ *
+ * @param date
+ * String
+ * @return Date jave.util Date object
+ */
+ public static Date convertStringToDateWithTime(String date) {
+ SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ format.setTimeZone(TimeZone.getTimeZone(Constants.TIME_ZONE));
+ Date afterFormat = null;
+ try {
+ afterFormat = format.parse(date);
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return afterFormat;
+ }
+
+ /**
+ * this method will provide current data in GMT.
+ *
+ * @return Date Object
+ */
+ public static Date getCurrentDateInGmt() {
+ Calendar c = Calendar.getInstance();
+ TimeZone z = c.getTimeZone();
+ int offset = z.getRawOffset();
+ if (z.inDaylightTime(new Date())) {
+ offset = offset + z.getDSTSavings();
+ }
+ int offsetHrs = offset / 1000 / 60 / 60;
+ int offsetMints = offset / 1000 / 60 % 60;
+ c.add(Calendar.HOUR_OF_DAY, (-offsetHrs));
+ c.add(Calendar.MINUTE, (-offsetMints));
+ return c.getTime();
+ }
+
+ /**
+ * this method is used to take system current time and return time with time
+ * zone.
+ *
+ * @param date
+ * current date
+ * @param timezone
+ * time
+ * @return String
+ */
+ public static String convertDateWithTimeZone(Date date, String timezone) {
+ SimpleDateFormat dateFormatGmt = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ dateFormatGmt.setTimeZone(TimeZone.getTimeZone(timezone));
+ return dateFormatGmt.format(date);
+
+ }
+
+ /**
+ * this method will convert String to date object with system time zone.
+ *
+ * @param date
+ * String
+ * @return Date
+ */
+ public static Date convertStringToDate(String date) {
+ SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ Date afterFormat = null;
+ try {
+ afterFormat = format.parse(date);
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return afterFormat;
+ }
+
+ /**
+ * this will format incoming date with MM/dd/yyyy
+ *
+ * @param date
+ * String
+ * @return String
+ */
+ public static String formateWithMMddyyyy(String date) {
+ SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");
+ String formattedDate = "";
+ try {
+ formattedDate = format.format(dateFormat.parse(date));
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+
+ return formattedDate;
+ }
+
+ /**
+ * This method will return reservation time and current time difference in
+ * minutes.
+ *
+ * @param date
+ * String reservation time
+ * @return int
+ */
+ public static int getDateDifferenceInMinutes(String date) {
+ int diffDate = 0;
+ SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
+ dateFormat.setTimeZone(TimeZone.getTimeZone(Constants.TIME_ZONE));
+ try {
+ Date requestedDate = dateFormat.parse(date);
+ Date currentDate = new Date();
+ currentDate = dateFormat.parse(dateFormat.format(currentDate));
+ diffDate = (int) ((requestedDate.getTime() - currentDate.getTime()) / 60000);
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return diffDate;
+ }
+
+ /**
+ * This method will formate incoming String to time zone and format.
+ *
+ * @param date
+ * @param timZone
+ * @param format
+ * @return
+ */
+ public static String formatStringToTimeZone(String date, String timZone, String format) {
+ SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+ dateFormat.setTimeZone(TimeZone.getTimeZone(timZone));
+ SimpleDateFormat dateFormat1 = new SimpleDateFormat(format);
+ dateFormat1.setTimeZone(TimeZone.getTimeZone(Constants.TIME_ZONE));
+ String formattedDate = date;
+ try {
+ Date parseDate = dateFormat.parse(date);
+ formattedDate = dateFormat1.format(parseDate);
+ formattedDate = dateFormat1.format(dateFormat1.parse(formattedDate));
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return formattedDate;
+ }
+
+ /**
+ * This method will provide current date in IST format in YYYY_MM_DD format.
+ *
+ * @return String
+ */
+ public static String getYyyyMmDdInIST() {
+ SimpleDateFormat format = new SimpleDateFormat(YYYYMMDD_FORMATTER);
+ format.setTimeZone(TimeZone.getTimeZone(Constants.TIME_ZONE));
+ return format.format(new Date());
+ }
+
+ /**
+ * this method will convert String to date object in IST
+ *
+ * @param date
+ * String
+ * @return Date
+ */
+ public static Date convertStringToDateIST(String date) {
+ SimpleDateFormat format = new SimpleDateFormat(YYYYMMDD_FORMATTER);
+ format.setTimeZone(TimeZone.getTimeZone(Constants.TIME_ZONE));
+ Date afterFormat = null;
+ try {
+ afterFormat = format.parse(date);
+ } catch (Exception e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return afterFormat;
+ }
+
+ public static String getTimeWithHHMMSSFormat() {
+
+ Calendar cal = Calendar.getInstance();
+ SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
+ return sdf.format(cal.getTime());
+
+ }
+
+ public static Date convertPorjectUploadDate(String date) {
+ SimpleDateFormat format = new SimpleDateFormat(DATE_MONTH_YEAR_FORMAT);
+ Date formatDate = null;
+ try {
+ formatDate = format.parse(date);
+ } catch (ParseException e) {
+ LOGGER.error(String.format(ENCOUNTERED_AN_EXCEPTION, e.getMessage()));
+ }
+ return formatDate;
+ }
+}
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
new file mode 100644
index 0000000000000000000000000000000000000000..3434466049ea180d8e16778601a098b223803f1e
--- /dev/null
+++ b/src/main/resources/application.properties
@@ -0,0 +1,46 @@
+# Details for our datasource
+spring.datasource.url=jdbc:postgresql://192.168.64.5:5432/grievance
+spring.datasource.username=postgres
+spring.datasource.password=postgres
+
+# Hibernate properties
+spring.jpa.database-platform=org.hibernate.dialect.PostgreSQL94Dialect
+spring.jpa.show-sql=true
+spring.jpa.hibernate.ddl-auto=none
+spring.jpa.hibernate.naming.implicit-strategy=org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl
+spring.jpa.properties.hibernate.format_sql=true
+spring.main.allow-bean-definition-overriding=true
+
+# ES config
+spring.data.elasticsearch.rest.uris=localhost:9200
+
+# Logging
+logging.level.org.upsmf.grievance=DEBUG
+es.default.page.size=20
+
+# WhiteListing
+urls.whitelist=
+
+# Mail
+spring.mail.host=smtp.gmail.com
+spring.mail.port=587
+spring.mail.username=upsmf.otp@upsmfac.org
+spring.mail.password=
+spring.mail.properties.mail.smtp.auth=true
+spring.mail.properties.mail.smtp.starttls.enable=true
+
+# Redis
+spring.redis.host=localhost
+spring.redis.port=6379
+
+# OTP expiration time in minutes
+otp.expiration.minutes=5
+
+# gcp config
+gcp.project.id=
+gcp.bucket.name=
+gcp.bucket.folder.name=grievance
+gcp.max.file.size=2mb
+gcp.config.file.path=/Users/shishirsuman/Desktop/upsmf.json
+gcp.client.id=
+
diff --git a/src/test/java/org/upsmf/notification/NotificationServiceApplicationTests.java b/src/test/java/org/upsmf/notification/NotificationServiceApplicationTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..989065555742c538198ad1965f00b661b24ccdcd
--- /dev/null
+++ b/src/test/java/org/upsmf/notification/NotificationServiceApplicationTests.java
@@ -0,0 +1,13 @@
+package org.upsmf.notification;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class NotificationServiceApplicationTests {
+
+ @Test
+ void contextLoads() {
+ }
+
+}