RELEASE : RELEASE : Create a brandnew skeleton for service masterdata H2 Slave

.gitignore

+.idea/
+mvnw
+mvnw.cmd
+Dockerfile

pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.3.2</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+    <groupId>com.eksad</groupId>
+    <artifactId>ddms-gigr-module-h3-slave</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>ddms-gigr-module-h3-slave</name>
+    <description></description>
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.springframework.boot</groupId>-->
+<!--            <artifactId>spring-boot-devtools</artifactId>-->
+<!--            <scope>runtime</scope>-->
+<!--            <optional>true</optional>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-api</artifactId>
+            <version>0.12.6</version>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-impl</artifactId>
+            <version>0.12.6</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-jackson</artifactId>
+            <version>0.12.6</version>
+            <scope>runtime</scope>
+        </dependency>
+
+        <!-- Spring Kafka -->
+        <dependency>
+            <groupId>org.springframework.kafka</groupId>
+            <artifactId>spring-kafka</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.vertx</groupId>
+            <artifactId>vertx-core</artifactId>
+            <version>4.1.2</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-compiler-plugin</artifactId>
+            <version>3.8.1</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${project.parent.version}</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>16</source>
+                    <target>16</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

src/main/java/com/eksad/masterdata/WebApplication.java

+package com.eksad.masterdata;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class WebApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(WebApplication.class, args);
+    }
+
+}

src/main/java/com/eksad/masterdata/common/Constants.java

+package com.eksad.masterdata.common;
+
+public class Constants {
+
+    public static final int MAX_LIMIT = 100;
+    public static final int ERROR_CODE_DATA_EXIST = 202;
+    public static final int ERROR_CODE_REQUIRED = 500;
+    public static final String SUCCESS = "SUCCESS";
+    public static final String ERROR = "ERROR";
+
+    public static class Login {
+        public static final String WRONG_PASSWORD = "User and Password does not match";
+        public static final String USER_NOT_FOUND = "User not found";
+        public static final String USER_INACTIVE = "Inactive user";
+        public static final String USER_BLOCK = "This user is blocked. Please wait for 1 minutes.";
+        public static final String STATUS_LOGOUT = "LOGOUT";
+
+    }
+
+    public static final String topicStep1 = "task-step1";
+    public static final String topicStep2 = "task-step2";
+}

src/main/java/com/eksad/masterdata/common/DateUtils.java

+package com.eksad.masterdata.common;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class DateUtils {
+
+    public static Date stringToDate(String date) throws Exception {
+        Date resultDate = null;
+        if (date != null) {
+            if (!date.isEmpty()) {
+                resultDate = new SimpleDateFormat("yyyy-MM-dd").parse(date);
+            }
+        }
+
+        return resultDate;
+    }
+}

src/main/java/com/eksad/masterdata/common/GenericResponseDTO.java

+package com.eksad.masterdata.common;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+import java.io.Serializable;
+
+public class GenericResponseDTO<T> implements Serializable {
+    private ResponseStatus status;
+    private int code;
+    private String message;
+    private T data;
+
+    @JsonIgnore
+    public GenericResponseDTO<T> successResponse() {
+        GenericResponseDTO<T> data = new GenericResponseDTO();
+        data.setStatus(ResponseStatus.S);
+        data.setCode(201);
+        data.setMessage("Process Successed");
+        return data;
+    }
+
+    @JsonIgnore
+    public GenericResponseDTO<T> successResponse(T t) {
+        GenericResponseDTO<T> data = new GenericResponseDTO();
+        data.setStatus(ResponseStatus.S);
+        data.setCode(201);
+        data.setData(t);
+        data.setMessage("Process Successed");
+        return data;
+    }
+
+    @JsonIgnore
+    public GenericResponseDTO<T> noDataFoundResponse(T t) {
+        GenericResponseDTO<T> data = new GenericResponseDTO();
+        data.setStatus(ResponseStatus.S);
+        data.setCode(204);
+        data.setData(t);
+        data.setMessage("No Data Found");
+        return data;
+    }
+
+    @JsonIgnore
+    public GenericResponseDTO<T> noDataFoundResponse() {
+        GenericResponseDTO<T> data = new GenericResponseDTO();
+        data.setStatus(ResponseStatus.S);
+        data.setCode(204);
+        data.setMessage("No Data Found");
+        return data;
+    }
+
+    @JsonIgnore
+    public GenericResponseDTO<T> errorResponse(int code, String message) {
+        GenericResponseDTO<T> data = new GenericResponseDTO();
+        data.setStatus(ResponseStatus.F);
+        data.setCode(code);
+        data.setMessage(message);
+        return data;
+    }
+
+    public void setStatus(ResponseStatus status) {
+        this.status = status;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public void setData(T data) {
+        this.data = data;
+    }
+
+    public ResponseStatus getStatus() {
+        return this.status;
+    }
+
+
+    public String getMessage() {
+        return this.message;
+    }
+
+    public T getData() {
+        return this.data;
+    }
+
+    public GenericResponseDTO() {
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public GenericResponseDTO(ResponseStatus status, int code, String message, T data) {
+        this.status = status;
+        this.code = code;
+        this.message = message;
+        this.data = data;
+    }
+}

src/main/java/com/eksad/masterdata/common/LogOpsDTO.java

+package com.eksad.masterdata.common;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+import java.util.Date;
+
+public class LogOpsDTO {
+
+    private String domain;
+    private String domainEvent;
+    private String domainClass;
+    private String domainParty;
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy HH:mm:ss", timezone = "GMT+7")
+    private Date timeEvent;
+    private String eventType;
+    private String eventOps;
+    private String user;
+    private Object data;
+
+    public String getDomain() {
+        return domain;
+    }
+
+    public void setDomain(String domain) {
+        this.domain = domain;
+    }
+
+    public String getDomainEvent() {
+        return domainEvent;
+    }
+
+    public void setDomainEvent(String domainEvent) {
+        this.domainEvent = domainEvent;
+    }
+
+    public String getDomainClass() {
+        return domainClass;
+    }
+
+    public void setDomainClass(String domainClass) {
+        this.domainClass = domainClass;
+    }
+
+    public String getDomainParty() {
+        return domainParty;
+    }
+
+    public void setDomainParty(String domainParty) {
+        this.domainParty = domainParty;
+    }
+
+    public Date getTimeEvent() {
+        return timeEvent;
+    }
+
+    public void setTimeEvent(Date timeEvent) {
+        this.timeEvent = timeEvent;
+    }
+
+    public String getEventType() {
+        return eventType;
+    }
+
+    public void setEventType(String eventType) {
+        this.eventType = eventType;
+    }
+
+    public String getEventOps() {
+        return eventOps;
+    }
+
+    public void setEventOps(String eventOps) {
+        this.eventOps = eventOps;
+    }
+
+    public String getUser() {
+        return user;
+    }
+
+    public void setUser(String user) {
+        this.user = user;
+    }
+
+    public Object getData() {
+        return data;
+    }
+
+    public void setData(Object data) {
+        this.data = data;
+    }
+
+    public LogOpsDTO(String domain, String domainEvent, String domainClass, String domainParty, Date timeEvent, String eventType, String eventOps, String user, Object data) {
+        this.domain = domain;
+        this.domainEvent = domainEvent;
+        this.domainClass = domainClass;
+        this.domainParty = domainParty;
+        this.timeEvent = timeEvent;
+        this.eventType = eventType;
+        this.eventOps = eventOps;
+        this.user = user;
+        this.data = data;
+    }
+
+    public LogOpsDTO() {
+    }
+}

src/main/java/com/eksad/masterdata/common/LogOpsUtil.java

+package com.eksad.masterdata.common;
+
+
+import java.util.Date;
+
+/**
+ *
+ * @author amy
+ */
+public class LogOpsUtil {
+
+    public static LogOpsDTO getLogOps(ProjectType projectType, String domain, String domainClass, String domainParty, Date timeEvent, String eventType, String eventOps, String user, Object data) {
+        return new LogOpsDTO(projectType.name() + domain, projectType.name() + domain + ".Request", domainClass, domainParty, timeEvent, domain + "." + eventType, domain + "." + eventOps, user, data);
+    }
+
+    public static LogResponseDTO getLogResponse(ProjectType projectType, String domain, Date timeEvent, String eventType, String eventOpsHttp, Object data) {
+        return new LogResponseDTO(projectType.name() + domain, projectType.name() + domain + ".Response", timeEvent, domain + "." + eventType + ".SUCCESS", eventOpsHttp, data);
+    }
+
+    public static LogResponseDTO getErrorResponse(ProjectType projectType, String domain, Date timeEvent, String eventType, String eventOpsHttp, Object data) {
+        return new LogResponseDTO(projectType.name() + domain, projectType.name() + domain + ".Response", timeEvent, domain + "." + eventType + ".ERROR", eventOpsHttp, data);
+    }
+}

src/main/java/com/eksad/masterdata/common/LogResponseDTO.java

+package com.eksad.masterdata.common;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+import java.util.Date;
+
+public class LogResponseDTO {
+
+    private String domain;
+    private String domainEvent;
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy HH:mm:ss", timezone = "GMT+7")
+    private Date timeEvent;
+    private String eventOpsStatus;
+    private String eventOpsHttp;
+    private Object data;
+
+    public String getDomain() {
+        return domain;
+    }
+
+    public void setDomain(String domain) {
+        this.domain = domain;
+    }
+
+    public String getDomainEvent() {
+        return domainEvent;
+    }
+
+    public void setDomainEvent(String domainEvent) {
+        this.domainEvent = domainEvent;
+    }
+
+    public Date getTimeEvent() {
+        return timeEvent;
+    }
+
+    public void setTimeEvent(Date timeEvent) {
+        this.timeEvent = timeEvent;
+    }
+
+    public String getEventOpsStatus() {
+        return eventOpsStatus;
+    }
+
+    public void setEventOpsStatus(String eventOpsStatus) {
+        this.eventOpsStatus = eventOpsStatus;
+    }
+
+    public String getEventOpsHttp() {
+        return eventOpsHttp;
+    }
+
+    public void setEventOpsHttp(String eventOpsHttp) {
+        this.eventOpsHttp = eventOpsHttp;
+    }
+
+    public Object getData() {
+        return data;
+    }
+
+    public void setData(Object data) {
+        this.data = data;
+    }
+
+    public LogResponseDTO() {
+    }
+
+    public LogResponseDTO(String domain, String domainEvent, Date timeEvent, String eventOpsStatus, String eventOpsHttp, Object data) {
+        this.domain = domain;
+        this.domainEvent = domainEvent;
+        this.timeEvent = timeEvent;
+        this.eventOpsStatus = eventOpsStatus;
+        this.eventOpsHttp = eventOpsHttp;
+        this.data = data;
+    }
+}

src/main/java/com/eksad/masterdata/common/ProjectType.java

+package com.eksad.masterdata.common;
+
+import java.util.Arrays;
+
+/**
+ *
+ * @author amy
+ */
+public enum ProjectType {
+    
+    CQRS("CQRS"),
+    CRUD("CRUD");
+
+    private String name;
+
+    ProjectType(String name) {
+        this.name = name;
+    }
+
+    public ProjectType findEnum(String name){
+        return Arrays.stream(values())
+                .filter(data -> data.name.equalsIgnoreCase(name))
+                .findFirst()
+                .orElse(null);
+    }
+}

src/main/java/com/eksad/masterdata/common/ResponseStatus.java

+package com.eksad.masterdata.common;
+
+import java.util.Arrays;
+
+public enum ResponseStatus {
+    S("Success"),
+    F("Failed");
+
+    private String name;
+
+    ResponseStatus(String name) {
+        this.name = name;
+    }
+
+    public ResponseStatus findEnum(String name) {
+        return (ResponseStatus) Arrays.stream(values()).filter((data) -> {
+            return data.name.equalsIgnoreCase(name);
+        }).findFirst().orElse(null);
+    }
+}

src/main/java/com/eksad/masterdata/common/StringUtil.java

+package com.eksad.masterdata.common;
+
+public class StringUtil {
+    public static Boolean isNullOrEmpty(String value){
+        return value.isEmpty() || value.isBlank() ? true : false;
+    }
+}

src/main/java/com/eksad/masterdata/config/JwtAuthenticationFilter.java

+package com.eksad.masterdata.config;
+
+import com.eksad.masterdata.model.User;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.lang.NonNull;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@Component
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+    @Value("${ddms.auth.token}")
+    private String secretKey;
+
+    @Override
+    protected void doFilterInternal(
+           @NonNull HttpServletRequest request,
+           @NonNull HttpServletResponse response,
+           @NonNull FilterChain filterChain)
+            throws ServletException, IOException {
+
+        String authHeader = request.getHeader("Authorization");
+        if(authHeader == null || !authHeader.startsWith("Bearer ")){
+            filterChain.doFilter(request, response);
+            return;
+        }
+
+        if (authHeader.equals(secretKey)) {
+            String username = "Admin";
+            if(username != null && SecurityContextHolder.getContext().getAuthentication() == null){
+                User objUser=new User();
+                UserDetails userDetails = objUser;
+                    UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
+                            userDetails, null, userDetails.getAuthorities()
+                    );
+
+                    authToken.setDetails(
+                            new WebAuthenticationDetailsSource().buildDetails(request)
+                    );
+
+                    SecurityContextHolder.getContext().setAuthentication(authToken);
+            }
+        }
+
+        filterChain.doFilter(request, response);
+    }
+}

src/main/java/com/eksad/masterdata/config/SecurityConfig.java

+package com.eksad.masterdata.config;
+
+import com.eksad.masterdata.service.UserDetailsServiceImp;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+@Configuration
+@EnableWebSecurity
+@EnableMethodSecurity
+public class SecurityConfig  {
+    private final UserDetailsServiceImp userDetailsServiceImp;
+    private final JwtAuthenticationFilter jwtAuthenticationFilter;
+
+    @Autowired
+    public SecurityConfig(UserDetailsServiceImp userDetailsServiceImp, JwtAuthenticationFilter jwtAuthenticationFilter) {
+        this.userDetailsServiceImp = userDetailsServiceImp;
+        this.jwtAuthenticationFilter = jwtAuthenticationFilter;
+    }
+
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception{
+        return http
+                .csrf(AbstractHttpConfigurer::disable)
+                .authorizeHttpRequests(
+                        req -> req.requestMatchers(
+                                "/api/authentication/**")
+                        .permitAll()
+                        .anyRequest()
+                        .authenticated()
+                )
+                .userDetailsService(userDetailsServiceImp)
+                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+                .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
+                .build();
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoder(){
+        return new BCryptPasswordEncoder();
+    }
+
+    @Bean
+    public AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) throws Exception {
+        return configuration.getAuthenticationManager();
+    }
+}

src/main/java/com/eksad/masterdata/controller/SampleGigrController.java

+package com.eksad.masterdata.controller;
+
+import com.eksad.masterdata.domain.MstWo;
+import com.eksad.masterdata.service.KafkaProducerService;
+import com.eksad.masterdata.service.ProcessHelperService;
+import com.eksad.masterdata.service.WOService;
+import io.vertx.core.json.JsonObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/masterdata")
+public class SampleGigrController {
+
+    @Autowired
+    ProcessHelperService processHelperService;
+
+    @Autowired
+    WOService woService;
+
+    @Autowired
+    KafkaProducerService kafkaProducerService;
+
+    @GetMapping("/test")
+    public ResponseEntity<String> test(){
+        System.out.println("test admin");
+        return ResponseEntity.ok("this is admin");
+    }
+
+    @GetMapping("/create")
+    public ResponseEntity<MstWo> create(){
+        MstWo response=woService.createNewWo();
+        return ResponseEntity.ok(response);
+    }
+
+    @GetMapping("/createLock")
+    public ResponseEntity<MstWo> createLock(){
+        MstWo response=woService.createNewWoLock();
+        return ResponseEntity.ok(response);
+    }
+
+    @PostMapping("/mqSend")
+    public ResponseEntity<String> mqSend(@RequestBody String request){
+        //to simplyfy tracing request lets generate transactionId
+        JsonObject jsonRequest=new JsonObject(request)
+                .put("transactionId",processHelperService.createProcessId());
+        kafkaProducerService.sendMessage(jsonRequest.encode());
+        JsonObject jsonResponse=new JsonObject()
+                .put("status","SUCCESS")
+                .put("message","message send successfully");
+        return ResponseEntity.ok(jsonResponse.encode());
+    }
+}

src/main/java/com/eksad/masterdata/domain/MstWo.java

+package com.eksad.masterdata.domain;
+
+import jakarta.persistence.*;
+
+import java.util.Date;
+
+@Entity
+@Table(name = "mst_wo")
+public class MstWo {
+    @Id
+    @Column(name = "wo_id")
+    private Long woId;
+
+    @Column(name = "nopol")
+    private String nopol;
+
+    @Column(name = "create_dt")
+    private Date createDt;
+
+    public Long getWoId() {
+        return this.woId;
+    }
+
+    public void setWoId(Long woId) {
+        this.woId = woId;
+    }
+
+    public String getNopol() {
+        return this.nopol;
+    }
+
+    public void setNopol(String nopol) {
+        this.nopol = nopol;
+    }
+
+    public Date getCreateDt() {
+        return this.createDt;
+    }
+
+    public void setCreateDt(Date createDt) {
+        this.createDt = createDt;
+    }
+}

src/main/java/com/eksad/masterdata/domain/TrxBizpar.java

+package com.eksad.masterdata.domain;
+
+import jakarta.persistence.*;
+
+import java.util.Date;
+
+@Entity
+@Table(name = "trx_bizpar")
+public class TrxBizpar {
+    @Id
+    @Column(name = "id")
+    private String id;
+
+    @Column(name = "bizpar_name")
+    private String bizparName;
+
+    @Column(name = "bizpar_textvalue")
+    private String bizparTextvalue;
+
+    @Column(name = "bizpar_numvalue")
+    private Long bizparNumvalue;
+
+    @Column(name = "bizpar_datevalue")
+    private Date bizparDatevalue;
+
+    public String getId() {
+        return this.id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getBizparName() {
+        return this.bizparName;
+    }
+
+    public void setBizparName(String bizparName) {
+        this.bizparName = bizparName;
+    }
+
+    public String getBizparTextvalue() {
+        return this.bizparTextvalue;
+    }
+
+    public void setBizparTextvalue(String bizparTextvalue) {
+        this.bizparTextvalue = bizparTextvalue;
+    }
+
+    public Long getBizparNumvalue() {
+        return this.bizparNumvalue;
+    }
+
+    public void setBizparNumvalue(Long bizparNumvalue) {
+        this.bizparNumvalue = bizparNumvalue;
+    }
+
+    public Date getBizparDatevalue() {
+        return this.bizparDatevalue;
+    }
+
+    public void setBizparDatevalue(Date bizparDatevalue) {
+        this.bizparDatevalue = bizparDatevalue;
+    }
+}

src/main/java/com/eksad/masterdata/event/KafkaEvent.java

+package com.eksad.masterdata.event;
+import com.eksad.masterdata.common.Constants;
+import io.vertx.core.json.JsonObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+public class KafkaEvent {
+
+    @Autowired
+    private KafkaTemplate<String, String> kafkaTemplate;
+
+    @KafkaListener(topics = Constants.topicStep1, groupId = "my-group")
+    public void listenStep1(String message) {
+        JsonObject jsonMessage=new JsonObject(message);
+        String transactionId=jsonMessage.getString("transactionId");
+        System.out.println(
+                String.format("Starting Step 1 - new taskid %s with paylod [[ %s ]]",
+                        transactionId,
+                        jsonMessage));
+        //do something here
+        jsonMessage.put("resultStep1","step 1 a success");
+
+        //lets continue to other queue
+        kafkaTemplate.send(Constants.topicStep2,jsonMessage.encode());
+
+        System.out.println(
+                String.format("done Step 1 for taskid %s %n%n",transactionId));
+    }
+
+    @KafkaListener(topics = Constants.topicStep2, groupId = "my-group")
+    public void listenStep2(String message) {
+        JsonObject jsonMessage=new JsonObject(message);
+        String transactionId=jsonMessage.getString("transactionId");
+        System.out.println(
+                String.format("Starting Step 2 - new taskid %s with paylod [[ %s ]]",
+                        transactionId,
+                        jsonMessage));
+        //do something here
+        jsonMessage.put("resultStep2","step 2 a success");
+
+        System.out.println(
+                String.format("done Step 2 for taskid %s with final result [[ %s ]] %n%n",
+                        transactionId,
+                        jsonMessage.encode()));
+    }
+}

src/main/java/com/eksad/masterdata/model/Role.java

+package com.eksad.masterdata.model;
+
+public enum Role {
+    USER,
+    ADMIN
+}

src/main/java/com/eksad/masterdata/model/User.java

+package com.eksad.masterdata.model;
+
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+
+import java.util.Collection;
+
+public class User implements UserDetails {
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        return null;
+    }
+
+    public String getPassword() {
+        return "";
+    }
+
+    @Override
+    public String getUsername() {
+        return "Admin";
+    }
+
+    @Override
+    public boolean isAccountNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isAccountNonLocked() {
+        return true;
+    }
+
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return true;
+    }
+
+}

src/main/java/com/eksad/masterdata/repository/BizparRepository.java

+package com.eksad.masterdata.repository;
+
+import com.eksad.masterdata.domain.TrxBizpar;
+import jakarta.persistence.LockModeType;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.query.Param;
+
+public interface BizparRepository extends CrudRepository<TrxBizpar,String> {
+
+    TrxBizpar findByBizparName(String bizparName);
+
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT b FROM TrxBizpar b where b.bizparName = :bizparName")
+    TrxBizpar findByBizparNameWithLock(@Param("bizparName") String bizparName);
+}

src/main/java/com/eksad/masterdata/repository/WoRepository.java

+package com.eksad.masterdata.repository;
+
+import com.eksad.masterdata.domain.MstWo;
+import org.springframework.data.repository.CrudRepository;
+
+public interface WoRepository extends CrudRepository<MstWo, Long> {
+}

src/main/java/com/eksad/masterdata/service/KafkaProducerService.java

+package com.eksad.masterdata.service;
+
+import com.eksad.masterdata.common.Constants;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+public class KafkaProducerService {
+
+    @Autowired
+    private KafkaTemplate<String, String> kafkaTemplate;
+
+    public void sendMessage(String message) {
+        kafkaTemplate.send(Constants.topicStep1, message);
+        System.out.println(String.format("done sending for new incoming task [%s bytes] %n%n",message.length()));
+    }
+}

src/main/java/com/eksad/masterdata/service/ProcessHelperService.java

+package com.eksad.masterdata.service;
+
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Random;
+
+@Service
+public class ProcessHelperService {
+
+    private String lastTransactionId="";
+    private long preId = (new Random().nextInt(1000));
+
+    public String createProcessId() {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS");
+        String transactionId;
+        LocalDateTime now = LocalDateTime.now();
+        String formatDateTime = now.format(formatter);
+        ++preId;
+        if (preId >= 1000) {
+            preId = 1;
+        }
+        //random between 1000 to 9000
+        Random currentRandom = new Random();
+        int currentRandomData=(currentRandom.nextInt(8001) + 1000);
+        transactionId = String.format("%s%s.%s", formatDateTime,
+                preId,currentRandomData);
+        if (transactionId.equalsIgnoreCase(lastTransactionId)) {
+            currentRandomData=(currentRandom.nextInt(8001) + 1000);
+            transactionId = String.format("%s%s.%s", formatDateTime,
+                    preId,currentRandomData);
+        }
+        lastTransactionId=transactionId;
+        return transactionId;
+    }
+}

src/main/java/com/eksad/masterdata/service/UserDetailsServiceImp.java

+package com.eksad.masterdata.service;
+
+import com.eksad.masterdata.model.User;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+@Service
+public class UserDetailsServiceImp implements UserDetailsService {
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        return new User();
+    }
+}

src/main/java/com/eksad/masterdata/service/WOService.java

+package com.eksad.masterdata.service;
+
+import com.eksad.masterdata.domain.MstWo;
+import com.eksad.masterdata.domain.TrxBizpar;
+import com.eksad.masterdata.repository.BizparRepository;
+import com.eksad.masterdata.repository.WoRepository;
+import jakarta.transaction.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Date;
+
+@Service
+@Transactional
+public class WOService {
+
+    @Autowired
+    WoRepository woRepository;
+
+    @Autowired
+    BizparRepository bizparRepository;
+
+    public MstWo createNewWo() {
+
+        TrxBizpar trxBizpar=bizparRepository.findByBizparName("wo_seq");
+        Long latestId=trxBizpar.getBizparNumvalue();
+        latestId++;
+        MstWo mstWo=new MstWo();
+        mstWo.setWoId(latestId);
+        mstWo.setNopol("B 1234 WOP");
+        mstWo.setCreateDt(new Date());
+        woRepository.save(mstWo);
+
+        //set new latest id
+        trxBizpar.setBizparNumvalue(latestId);
+        bizparRepository.save(trxBizpar);
+        return mstWo;
+    }
+
+    public MstWo createNewWoLock() {
+
+        TrxBizpar trxBizpar=bizparRepository.findByBizparNameWithLock("wo_seq");
+        Long latestId=trxBizpar.getBizparNumvalue();
+        latestId++;
+        MstWo mstWo=new MstWo();
+        mstWo.setWoId(latestId);
+        mstWo.setNopol("B 1234 WOP");
+        mstWo.setCreateDt(new Date());
+        woRepository.save(mstWo);
+
+        //set new latest id
+        trxBizpar.setBizparNumvalue(latestId);
+        bizparRepository.save(trxBizpar);
+        return mstWo;
+    }
+}

src/main/resources/application-dev.properties

+server.port=8081
+
+
+spring.datasource.url = jdbc:postgresql://localhost:5432/postgres
+spring.datasource.username = postgres
+spring.datasource.password = password.1
+spring.jpa.generate-ddl=false
+spring.jpa.hibernate.ddl-auto = none
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
+
+spring.jpa.properties.hibernate.format_sql=true
+logging.level.org.hibernate.SQL=DEBUG
+logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
+
+ddms.auth.token=Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJhZG1pbiJ9.5BG9SEVOGo_xRhtT8IkyoSy60kPg8HM9Vpvb0TdNew4
+
+#Kafka Config
+#-----------------------------------------------------------------------
+# Kafka Bootstrap Server
+spring.kafka.bootstrap-servers=localhost:9092
+
+# Kafka Producer Configuration
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
+
+# Kafka Consumer Configuration
+spring.kafka.consumer.group-id=my-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+
+# Kafka Topic Name
+kafka.topic.name=pipeline-topic
\ No newline at end of file

src/main/resources/application-prod.properties

+server.port=8081
+
+spring.datasource.url = jdbc:postgresql://localhost:5432/postgres
+spring.datasource.username = postgres
+spring.datasource.password = password.1
+spring.jpa.generate-ddl=false
+spring.jpa.hibernate.ddl-auto = none
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
+
+spring.jpa.properties.hibernate.format_sql=true
+logging.level.org.hibernate.SQL=ERROR
+#logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
+
+

src/main/resources/application.properties

+#please define with dev-prod for profiles below
+spring.profiles.active=dev
+
+
+
+
+