Merge pull request #27 from Kitzanos/develop

First Deploy

.gitignore

@@ -1,24 +1,42 @@
-# Compiled class file
+HELP.md
-*.class
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+### DS_Store ###
+.DS_Store
+/bin/
+
 
-# Log file
-*.log
 
-# BlueJ files
-*.ctxt
 
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
 
-# Package Files #
-*.jar
-*.war
-*.nar
-*.ear
-*.zip
-*.tar.gz
-*.rar
 
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-replay_pid*

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

Dockerfile

@@ -0,0 +1,4 @@
+FROM amazoncorretto:17.0.8-alpine3.17
+EXPOSE 8080
+ADD /target/tendermanagement-0.0.1-SNAPSHOT.jar tendermanagement-0.0.1-SNAPSHOT.jar
+ENTRYPOINT ["java", "-jar","tendermanagement-0.0.1-SNAPSHOT.jar"]

Jenkinsfile

@@ -0,0 +1,64 @@
+pipeline {
+  agent any
+  options {
+    buildDiscarder logRotator(artifactDaysToKeepStr: '', artifactNumToKeepStr: '5', daysToKeepStr: '', numToKeepStr: '5')
+  }
+  stages {
+    stage('Develop Branch Deploy Code') {
+      when {
+          branch 'develop'
+      }
+      environment {
+        github_branch = "develop"
+        dockerimagename = "devteambflows/gepafin-api-dev"
+        dockerImage = ""
+        registryCredential = 'dockerhublogin'
+      }
+      steps {
+        git branch: "${github_branch}", url: 'https://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@github.com/Kitzanos/GEPAFIN-BE.git'
+        script {
+          sh '/usr/share/maven/bin/mvn clean install -Dmaven.test.skip=true -Dspring.profiles.active=dev'
+        }
+        script {
+          dockerImage = docker.build dockerimagename
+        }
+        script {
+          docker.withRegistry('https://registry.hub.docker.com', registryCredential) {
+            dockerImage.push("latest")
+          }
+        }
+        script {
+          sh 'ssh ubuntu@jenkins-server1.bflows.ai "sh gepafin-dev-api.sh"'
+        }
+      }
+    }
+    stage('Production Branch Deploy Code') {
+      when {
+          branch 'master'
+      }
+      environment {
+        github_branch = "master"
+        dockerimagename = "devteambflows/gepafin-api-production"
+        dockerImage = ""
+        registryCredential = 'dockerhublogin'
+      }
+      steps {
+        git branch: "${github_branch}", url: 'https://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@github.com/Kitzanos/GEPAFIN-BE.git'
+        script {
+          sh '/usr/share/maven/bin/mvn clean install -Dmaven.test.skip=true -Dspring.profiles.active=production'
+        }
+        script {
+          dockerImage = docker.build dockerimagename
+        }
+        script {
+          docker.withRegistry('https://registry.hub.docker.com', registryCredential) {
+            dockerImage.push("latest")
+          }
+        }
+        script {
+           sh 'ssh ubuntu@79.137.88.15 "sh gepafin-production-api.sh"'
+        }
+      }
+    }
+  }
+}

README.md

@@ -1,2 +1,3 @@
 # GEPAFIN-BE
 Back Gepafin Project
+Please add doc here

mvnw

@@ -0,0 +1,259 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.2
+#
+# Optional ENV vars
+# -----------------
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
+# ----------------------------------------------------------------------------
+
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
+
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
+
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
+
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
+      fi
+    fi
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
+
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
+  fi
+}
+
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
+  done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
+
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"${0%/*}/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in ${0%/*}/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${0##*/mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
+
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
+
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
+fi
+
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
+fi
+
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
+fi
+
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
+fi
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
+fi
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
+
+clean || :
+exec_maven "$@"

mvnw.cmd

@@ -0,0 +1,149 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    https://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.2
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" (%__MVNW_CMD__% %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace '^.*'+$MVNW_REPO_PATTERN,'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+$MAVEN_HOME_PARENT = "$HOME/.m2/wrapper/dists/$distributionUrlNameMain"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_HOME_PARENT = "$env:MAVEN_USER_HOME/wrapper/dists/$distributionUrlNameMain"
+}
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.MD5]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"

pom.xml

@@ -0,0 +1,207 @@
+<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>net.gepafin</groupId>
+	<artifactId>tendermanagement</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<name>tendermanagement</name>
+	<description>Tender Management project</description>
+	<properties>
+		<java.version>17</java.version>
+		<mapstruct.version>1.5.5.Final</mapstruct.version> <!-- MapStruct version -->
+	</properties>
+	<dependencies>
+		<!-- Spring Boot Starter Web for REST API -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-web</artifactId>
+		</dependency>
+
+		<!-- Lombok for reducing boilerplate code -->
+		<dependency>
+			<groupId>org.projectlombok</groupId>
+			<artifactId>lombok</artifactId>
+		</dependency>
+
+		<!-- H2 Database for in-memory testing -->
+		<dependency>
+			<groupId>com.h2database</groupId>
+			<artifactId>h2</artifactId>
+		</dependency>
+
+		<!-- PostgreSQL Database -->
+		<dependency>
+			<groupId>org.postgresql</groupId>
+			<artifactId>postgresql</artifactId>
+		</dependency>
+
+		<!-- Spring Boot Starter Data JPA for JPA and Hibernate -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-data-jpa</artifactId>
+		</dependency>
+
+		<!-- Springdoc OpenAPI for API Documentation -->
+		<dependency>
+			<groupId>org.springdoc</groupId>
+			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+			<version>2.2.0</version>
+		</dependency>
+
+		<!-- MapStruct for object mapping -->
+		<dependency>
+			<groupId>org.mapstruct</groupId>
+			<artifactId>mapstruct</artifactId>
+			<version>${mapstruct.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.mapstruct</groupId>
+			<artifactId>mapstruct-processor</artifactId>
+			<version>${mapstruct.version}</version>
+			<scope>provided</scope>
+		</dependency>
+
+		<dependency>
+            <groupId>org.liquibase</groupId>
+            <artifactId>liquibase-core</artifactId>
+        </dependency>
+
+		<!-- Spring Boot Starter Test for unit and integration tests -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>com.amazonaws</groupId>
+			<artifactId>aws-java-sdk-s3</artifactId>
+			<version>1.12.312</version>
+		</dependency>
+
+		<dependency>
+			<groupId>com.amazonaws</groupId>
+			<artifactId>aws-java-sdk-core</artifactId>
+			<version>1.12.341</version> 
+		</dependency>
+
+		<dependency>
+			<groupId>commons-io</groupId>
+			<artifactId>commons-io</artifactId>
+			<version>2.11.0</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-security</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>io.jsonwebtoken</groupId>
+			<artifactId>jjwt-api</artifactId>
+			<version>0.11.5</version>
+		</dependency>
+		<dependency>
+			<groupId>io.jsonwebtoken</groupId>
+			<artifactId>jjwt-impl</artifactId>
+			<version>0.11.5</version>
+		</dependency>
+		<dependency>
+			<groupId>io.jsonwebtoken</groupId>
+			<artifactId>jjwt-jackson</artifactId>
+			<version>0.11.5</version>
+		</dependency>
+		<dependency>
+		    <groupId>jakarta.validation</groupId>
+		    <artifactId>jakarta.validation-api</artifactId>
+		</dependency>
+		<dependency>
+		    <groupId>org.hibernate.validator</groupId>
+		    <artifactId>hibernate-validator</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>com.google.code.gson</groupId>
+			<artifactId>gson</artifactId>
+		</dependency>
+
+		<dependency>
+		    <groupId>org.zalando</groupId>
+		    <artifactId>problem-spring-web</artifactId>
+		    <version>0.23.0</version>
+		</dependency>
+		
+		<!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-saml2-service-provider -->
+		<dependency>
+	        <groupId>org.springframework.security</groupId>
+	        <artifactId>spring-security-saml2-service-provider</artifactId>
+	    </dependency>
+
+		<!-- https://mvnrepository.com/artifact/org.opensaml/opensaml-core -->
+		<dependency>
+		    <groupId>org.opensaml</groupId>
+		    <artifactId>opensaml-core</artifactId>
+		 <version>4.2.0</version>
+		</dependency>
+	
+		
+		<!-- https://mvnrepository.com/artifact/org.opensaml/opensaml-saml-api -->
+		<dependency>
+		    <groupId>org.opensaml</groupId>
+		    <artifactId>opensaml-saml-api</artifactId>
+		    <version>4.2.0</version>
+		</dependency>
+		
+			
+		<!-- https://mvnrepository.com/artifact/org.opensaml/opensaml-saml-impl -->
+		<dependency>
+		    <groupId>org.opensaml</groupId>
+		    <artifactId>opensaml-saml-impl</artifactId>
+		    <version>4.2.0</version>
+		</dependency>
+
+
+
+		<dependency>
+			<groupId>org.springframework.cloud</groupId>
+			<artifactId>spring-cloud-starter-openfeign</artifactId>
+			<version>4.1.3</version>
+		</dependency>
+		
+		<dependency>
+    <groupId>org.apache.santuario</groupId>
+    <artifactId>xmlsec</artifactId>
+    <version>2.3.0</version> <!-- or latest -->
+</dependency>
+
+
+	</dependencies>
+<repositories>
+    <repository>
+        <id>shibboleth</id>
+        <url>https://build.shibboleth.net/nexus/content/repositories/releases/</url>
+    </repository>
+</repositories>
+
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+			</plugin>
+			<plugin>
+				<groupId>org.liquibase</groupId>
+				<artifactId>liquibase-maven-plugin</artifactId>
+				<configuration>
+					<propertyFile>src/main/resources/application.properties</propertyFile>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>

src/main/java/net/gepafin/tendermanagement/TendermanagementApplication.java

@@ -0,0 +1,32 @@
+package net.gepafin.tendermanagement;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@EnableScheduling
+@EnableFeignClients
+@SpringBootApplication
+public class TendermanagementApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(TendermanagementApplication.class, args);
+		System.out.println("Spring Boot started");
+	}
+	
+	@Configuration
+	public class CorsConfig implements WebMvcConfigurer {
+
+		@Override
+		public void addCorsMappings(CorsRegistry registry) {
+			registry.addMapping("/**").allowedOrigins("http://localhost:3000")
+					.allowedMethods("GET", "POST", "PUT", "DELETE", "HEAD").allowCredentials(true);
+		}
+	}
+
+}
+

src/main/java/net/gepafin/tendermanagement/config/AmazonConfig.java

@@ -0,0 +1,34 @@
+package net.gepafin.tendermanagement.config;
+
+import com.amazonaws.auth.AWSCredentials;
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.AmazonS3ClientBuilder;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class AmazonConfig {
+
+    @Value("${aws.access.key.id}")
+    private String accessKey;
+
+    @Value("${aws.secret.access.key}")
+    private String secretKey;
+
+    @Value("${aws.s3.region}")
+    private String region;
+
+    @Bean
+    public AmazonS3 mementoBucket() {
+        AWSCredentials awsCredentials =
+                new BasicAWSCredentials(accessKey, secretKey);
+        return AmazonS3ClientBuilder
+                .standard()
+                .withRegion(region)
+                .withCredentials(new AWSStaticCredentialsProvider(awsCredentials))
+                .build();
+    }
+}

src/main/java/net/gepafin/tendermanagement/config/MessageSourceConfig.java

@@ -0,0 +1,17 @@
+package net.gepafin.tendermanagement.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.support.ResourceBundleMessageSource;
+
+@Configuration
+public class MessageSourceConfig {
+    @Bean(name = "defaultMessageSource")
+    public ResourceBundleMessageSource messageSource() {
+        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
+        messageSource.setBasenames("message");
+        messageSource.setDefaultEncoding("UTF-8");
+        messageSource.setUseCodeAsDefaultMessage(true);
+        return messageSource;
+    }
+}

src/main/java/net/gepafin/tendermanagement/config/SamlConfig.java

@@ -0,0 +1,197 @@
+package net.gepafin.tendermanagement.config;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.security.KeyFactory;
+import java.security.PrivateKey;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.time.Instant;
+import java.util.UUID;
+
+import org.bouncycastle.util.io.pem.PemReader;
+import org.opensaml.core.xml.config.XMLObjectProviderRegistrySupport;
+import org.opensaml.saml.common.SAMLVersion;
+import org.opensaml.saml.common.xml.SAMLConstants;
+import org.opensaml.saml.saml2.core.AuthnContextClassRef;
+import org.opensaml.saml.saml2.core.AuthnContextComparisonTypeEnumeration;
+import org.opensaml.saml.saml2.core.AuthnRequest;
+import org.opensaml.saml.saml2.core.RequestedAuthnContext;
+import org.opensaml.saml.saml2.core.impl.AuthnContextClassRefBuilder;
+import org.opensaml.saml.saml2.core.impl.RequestedAuthnContextBuilder;
+import org.opensaml.security.x509.BasicX509Credential;
+import org.opensaml.xmlsec.config.impl.DefaultSecurityConfigurationBootstrap;
+import org.opensaml.xmlsec.signature.Signature;
+import org.opensaml.xmlsec.signature.support.SignatureConstants;
+import org.opensaml.xmlsec.signature.support.Signer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.saml2.core.Saml2X509Credential;
+import org.springframework.security.saml2.provider.service.registration.InMemoryRelyingPartyRegistrationRepository;
+import org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistration;
+import org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistrationRepository;
+import org.springframework.security.saml2.provider.service.registration.Saml2MessageBinding;
+import org.springframework.security.saml2.provider.service.web.DefaultRelyingPartyRegistrationResolver;
+import org.springframework.security.saml2.provider.service.web.RelyingPartyRegistrationResolver;
+import org.springframework.security.saml2.provider.service.web.authentication.OpenSaml4AuthenticationRequestResolver;
+import org.springframework.security.saml2.provider.service.web.authentication.Saml2AuthenticationRequestResolver;
+
+@Configuration
+public class SamlConfig {
+
+    private final Logger logger = LoggerFactory.getLogger(SamlConfig.class);
+
+    @Value("${base-url}")
+    String baseUrl;
+
+    @Bean
+    public RelyingPartyRegistrationRepository relyingPartyRegistrationRepository() {
+
+        String entityId = baseUrl + "/v1/saml/gw/metadata";
+        String acsUrl = baseUrl + "/login/saml2/sso/loginumbria";
+
+        RelyingPartyRegistration registration = RelyingPartyRegistration.withRegistrationId("loginumbria")
+                .entityId(entityId)
+                .signingX509Credentials(credentials -> {
+                    try {
+                        credentials.add(Saml2X509Credential.signing(readPrivateKey(), readCertificate()));
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                })
+                .assertionConsumerServiceLocation(acsUrl)
+                .assertingPartyDetails(details -> details.entityId("https://federatest.umbriadigitale.it/gw/metadata")
+                    .singleSignOnServiceLocation("https://federatest.umbriadigitale.it/gw/SSOProxy/SAML2")
+                    .singleSignOnServiceBinding(Saml2MessageBinding.POST)
+                    .wantAuthnRequestsSigned(true)
+                    .verificationX509Credentials(credentials -> {
+                        try {
+                            // Load the IDP's public certificate for verifying the SAML response signature
+                            credentials.add(Saml2X509Credential.verification(readIdpCertificate()));
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                    })
+                )
+                .build();
+
+        return new InMemoryRelyingPartyRegistrationRepository(registration);
+    }
+    
+    public AuthnRequest createSignedAuthnRequest(PrivateKey privateKey, X509Certificate certificate) throws Exception {
+        AuthnRequest authnRequest = (AuthnRequest) XMLObjectProviderRegistrySupport.getBuilderFactory()
+                .getBuilder(AuthnRequest.DEFAULT_ELEMENT_NAME)
+                .buildObject(AuthnRequest.DEFAULT_ELEMENT_NAME);
+
+        authnRequest.setID("_" + UUID.randomUUID().toString());
+        authnRequest.setVersion(SAMLVersion.VERSION_20);
+       // authnRequest.setIssueInstant(new DateTime());
+        authnRequest.setIssueInstant(Instant.now());
+
+
+        // Sign the AuthnRequest
+       // BasicCredential signingCredential = new BasicCredential(certificate, privateKey);
+        BasicX509Credential signingCredential = new BasicX509Credential(certificate, privateKey);
+
+        Signature signature = (Signature) XMLObjectProviderRegistrySupport.getBuilderFactory()
+                .getBuilder(Signature.DEFAULT_ELEMENT_NAME)
+                .buildObject(Signature.DEFAULT_ELEMENT_NAME);
+
+        signature.setCanonicalizationAlgorithm(SignatureConstants.ALGO_ID_C14N_EXCL_OMIT_COMMENTS); 
+        signature.setSigningCredential(signingCredential);
+        signature.setSignatureAlgorithm(SignatureConstants.ALGO_ID_SIGNATURE_RSA_SHA1); // Set RSA-SHA1
+
+        authnRequest.setSignature(signature);
+        DefaultSecurityConfigurationBootstrap.buildDefaultSignatureSigningConfiguration();
+
+        // Marshall and sign the object
+        XMLObjectProviderRegistrySupport.getMarshallerFactory().getMarshaller(authnRequest).marshall(authnRequest);
+        Signer.signObject(signature);
+
+        return authnRequest;
+    }
+
+@Bean
+public Saml2AuthenticationRequestResolver authenticationRequestResolver(RelyingPartyRegistrationRepository registrations) {
+    RelyingPartyRegistrationResolver registrationResolver = new DefaultRelyingPartyRegistrationResolver(registrations);
+    OpenSaml4AuthenticationRequestResolver authenticationRequestResolver = new OpenSaml4AuthenticationRequestResolver(registrationResolver);
+
+    authenticationRequestResolver.setAuthnRequestCustomizer((context) -> {
+        // Set the required attributes
+        AuthnRequest authnRequest = context.getAuthnRequest();
+        authnRequest.setID("_" + UUID.randomUUID().toString()); // Add a unique ID
+        authnRequest.setVersion(SAMLVersion.VERSION_20); // Ensure version is 2.0
+        authnRequest.setProtocolBinding(SAMLConstants.SAML2_POST_BINDING_URI); // HTTP-POST
+
+        // Set Authentication Context
+        authnRequest.setRequestedAuthnContext(buildRequestedAuthnContext());
+
+        // Log the SAML AuthnRequest after setting context
+        String samlRequest = SamlRequestLogger.convertSAMLObjectToString(authnRequest);
+        logger.info("SAML AuthnRequest after setting context: " + samlRequest);
+    });
+
+    return authenticationRequestResolver;
+}
+
+private RequestedAuthnContext buildRequestedAuthnContext() {
+    AuthnContextClassRefBuilder authnContextClassRefBuilder = new AuthnContextClassRefBuilder();
+    AuthnContextClassRef authnContextClassRef = authnContextClassRefBuilder.buildObject(
+        SAMLConstants.SAML20_NS, AuthnContextClassRef.DEFAULT_ELEMENT_LOCAL_NAME, SAMLConstants.SAML20_PREFIX
+    );
+    // Set the SPID Level 2 authentication context
+    authnContextClassRef.setURI("urn:oasis:names:tc:SAML:2.0:ac:classes:SecureRemotePassword");
+
+    RequestedAuthnContextBuilder requestedAuthnContextBuilder = new RequestedAuthnContextBuilder();
+    RequestedAuthnContext requestedAuthnContext = requestedAuthnContextBuilder.buildObject();
+    requestedAuthnContext.setComparison(AuthnContextComparisonTypeEnumeration.EXACT);
+    requestedAuthnContext.getAuthnContextClassRefs().add(authnContextClassRef);
+
+    return requestedAuthnContext;
+}
+    
+    public PrivateKey readPrivateKey() throws Exception {
+        // Path to your private key PEM file
+        try (PemReader pemReader = new PemReader(new InputStreamReader(readKey("dev/saml/private-key.pem")))) {
+            // Read the PEM content
+            byte[] pemContent = pemReader.readPemObject().getContent();
+            // Decode the PEM content
+            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pemContent);
+            KeyFactory keyFactory = KeyFactory.getInstance("RSA"); // Use RSA algorithm
+            // Generate and return the PrivateKey
+            return keyFactory.generatePrivate(keySpec);
+        }
+    }
+    public X509Certificate readCertificate() throws Exception {
+        // Path to your certificate PEM fileFile
+        try (InputStream inStream = readKey("dev/saml/public-cert.pem")) {
+            CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
+            return (X509Certificate) certFactory.generateCertificate(inStream);
+        }
+    }
+    
+    public X509Certificate readIdpCertificate() throws Exception {
+        // Path to your IDP public certificate PEM file
+        try (InputStream inStream = readKey("dev/saml/idp-certificate.pem")) {
+            CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
+            return (X509Certificate) certFactory.generateCertificate(inStream);
+        }
+    }
+
+    
+    public InputStream readKey(String path) throws IOException {
+        ClassLoader classLoader = getClass().getClassLoader();
+        InputStream inputStream = classLoader.getResourceAsStream(path);
+        
+        if (inputStream == null) {
+            throw new FileNotFoundException("file not found : "+path);
+        }
+        return inputStream;
+    }
+}

src/main/java/net/gepafin/tendermanagement/config/SamlFailureHandler.java

@@ -0,0 +1,35 @@
+package net.gepafin.tendermanagement.config;
+
+import java.io.IOException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.authentication.AuthenticationFailureHandler;
+import org.springframework.stereotype.Component;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+@Component
+public class SamlFailureHandler implements AuthenticationFailureHandler {
+	
+    private final Logger logger = LoggerFactory.getLogger(SamlSuccessHandler.class);
+    
+	@Value("${fe.base.url}")
+	private String feBaseUrl;
+	
+	@Override
+    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
+                                        AuthenticationException exception) throws IOException {
+        try {
+            logger.error("SAML login failed: " + exception.getMessage());
+
+			response.sendRedirect(feBaseUrl + "/login");
+        } catch (Exception e) {
+            logger.error("Error processing SAML failure handler", e);
+        }
+    }
+	
+}

src/main/java/net/gepafin/tendermanagement/config/SamlRequestLogger.java

@@ -0,0 +1,22 @@
+package net.gepafin.tendermanagement.config;
+
+import org.opensaml.core.xml.io.MarshallingException;
+import org.opensaml.core.xml.util.XMLObjectSupport;
+import org.opensaml.saml.saml2.core.AuthnRequest;
+import org.w3c.dom.Element;
+
+import net.shibboleth.utilities.java.support.xml.SerializeSupport;
+
+public class SamlRequestLogger {
+
+    public static String convertSAMLObjectToString(AuthnRequest authnRequest) {
+        try {
+            Element element = XMLObjectSupport.marshall(authnRequest);
+            return SerializeSupport.prettyPrintXML(element); // Pretty print XML using SerializeSupport
+        } catch (MarshallingException e) {
+            e.printStackTrace();
+            return "Error converting SAML object to XML";
+        }
+    }
+}
+

src/main/java/net/gepafin/tendermanagement/config/SamlSuccessHandler.java

@@ -0,0 +1,97 @@
+package net.gepafin.tendermanagement.config;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.saml2.provider.service.authentication.Saml2AuthenticatedPrincipal;
+import org.springframework.security.saml2.provider.service.authentication.Saml2Authentication;
+import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
+import org.springframework.stereotype.Component;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.SamlResponseEntity;
+import net.gepafin.tendermanagement.entities.UserEntity;
+import net.gepafin.tendermanagement.repositories.SamlResponseRepository;
+import net.gepafin.tendermanagement.repositories.UserRepository;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+
+@Component
+public class SamlSuccessHandler implements AuthenticationSuccessHandler {
+
+	private final Logger logger = LoggerFactory.getLogger(SamlSuccessHandler.class);
+
+	@Autowired
+	private SamlResponseRepository samlResponseLogRepository;
+
+	@Autowired
+	private UserRepository userRepository;
+
+	@Value("${fe.base.url}")
+	private String feBaseUrl;
+
+	@Override
+	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
+			Authentication authentication) throws IOException {
+		try {
+			Saml2Authentication samlAuth = (Saml2Authentication) authentication;
+			Saml2AuthenticatedPrincipal principal = (Saml2AuthenticatedPrincipal) samlAuth.getPrincipal();
+
+			Map<String, List<Object>> userAttributes = principal.getAttributes();
+			String token = Utils.generateSecureToken();
+			logger.info("SAML User Attributes: " + userAttributes);
+
+			SamlResponseEntity samlResponseLogEntity = new SamlResponseEntity();
+			samlResponseLogEntity.setAuthenticationObject(authentication.toString());
+
+			ObjectMapper objectMapper = new ObjectMapper();
+			String userAttributesJson = objectMapper.writeValueAsString(userAttributes);
+			samlResponseLogEntity.setAuthenticationObject(userAttributesJson);
+			samlResponseLogEntity.setToken(token);
+			samlResponseLogRepository.save(samlResponseLogEntity);
+			
+			String redirectUrl = feBaseUrl;
+
+			logger.info("SAML login successful for user: " + principal.getName());
+			String cf = userAttributes.get("CodiceFiscale").get(0).toString();
+			UserEntity userEntity = userRepository.findByCodiceFiscale(cf).orElse(null);
+			if (userEntity == null) {
+				redirectUrl += "/registration?temp_token=" + token;
+			} else {
+				redirectUrl += "/login?temp_token=" + token;
+			}
+			response.sendRedirect(redirectUrl);
+			logger.info("SAML redirect Url: " + redirectUrl);
+		} catch (Exception e) {
+			logger.error("Error processing SAML success handler", e);
+		}
+	}
+
+	public void validateToken(String token, String codiceFiscale) {
+		SamlResponseEntity samlResponseLogEntity = samlResponseLogRepository.findByToken(token);
+		if (samlResponseLogEntity == null) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.INVALID_TOKEN_MSG));
+		}
+		Map<String, List<Object>> userAttributes = Utils
+				.convertStringIntoMap(samlResponseLogEntity.getAuthenticationObject());
+		String cf = userAttributes.get("CodiceFiscale").get(0).toString();
+		if (codiceFiscale == null || Boolean.FALSE.equals(codiceFiscale.equals(cf))) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.INVALID_TOKEN_MSG));
+		}
+		samlResponseLogRepository.delete(samlResponseLogEntity);
+	}
+
+}

src/main/java/net/gepafin/tendermanagement/config/SchemaInit.java

@@ -0,0 +1,70 @@
+package net.gepafin.tendermanagement.config;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import javax.sql.DataSource;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.AbstractDependsOnBeanFactoryPostProcessor;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
+import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.stereotype.Component;
+
+import liquibase.change.DatabaseChange;
+import liquibase.integration.spring.SpringLiquibase;
+import org.springframework.beans.factory.annotation.Value;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Configuration
+@ConditionalOnClass({ SpringLiquibase.class, DatabaseChange.class })
+@ConditionalOnProperty(prefix = "spring.liquibase", name = "enabled", matchIfMissing = true)
+@AutoConfigureAfter({ DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class })
+@Import({SchemaInit.SpringLiquibaseDependsOnPostProcessor.class})
+public class SchemaInit {
+
+    @Component
+    @ConditionalOnProperty(prefix = "spring.liquibase", name = "enabled", matchIfMissing = true)
+    public static class SchemaInitBean implements InitializingBean {
+
+        private final DataSource dataSource;
+        private final String schemaName;
+
+        @Autowired
+        public SchemaInitBean(DataSource dataSource, @Value("${spring.liquibase.default-schema}") String schemaName) {
+            this.dataSource = dataSource;
+            this.schemaName = schemaName;
+        }
+
+        @Override
+        public void afterPropertiesSet() {
+            try (Connection conn = dataSource.getConnection();
+                 Statement statement = conn.createStatement()) {
+                log.info("Going to create DB schema '{}' if not exists.", schemaName);
+                String query = "create schema if not exists " + schemaName;
+                statement.execute(query);
+            } catch (SQLException e) {
+                throw new RuntimeException("Failed to create schema '" + schemaName + "'", e);
+            }
+        }
+    }
+
+
+    @ConditionalOnBean(SchemaInitBean.class)
+    static class SpringLiquibaseDependsOnPostProcessor extends AbstractDependsOnBeanFactoryPostProcessor {
+
+        SpringLiquibaseDependsOnPostProcessor() {
+            // Configure the 3rd party SpringLiquibase bean to depend on our SchemaInitBean
+            super(SpringLiquibase.class, SchemaInitBean.class);
+        }
+    }
+}

src/main/java/net/gepafin/tendermanagement/config/SecurityConfig.java

@@ -0,0 +1,136 @@
+package net.gepafin.tendermanagement.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.http.HttpMethod;
+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.configuration.WebSecurityCustomizer;
+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;
+import org.springframework.security.web.servlet.util.matcher.MvcRequestMatcher;
+import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+import org.springframework.web.filter.CorsFilter;
+import org.springframework.web.servlet.handler.HandlerMappingIntrospector;
+
+
+import io.swagger.v3.oas.models.Components;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.security.SecurityRequirement;
+import io.swagger.v3.oas.models.security.SecurityScheme;
+import io.swagger.v3.oas.models.servers.Server;
+import net.gepafin.tendermanagement.config.jwt.JWTFilter;
+import net.gepafin.tendermanagement.config.jwt.TokenProvider;
+
+@Configuration
+@EnableWebSecurity
+@EnableMethodSecurity(prePostEnabled = true)
+public class SecurityConfig {
+    private final TokenProvider tokenProvider;
+    private final SamlSuccessHandler samlSuccessHandler;
+    private final SamlFailureHandler samlFailureHandler;
+    
+    @Value("${base-url}") 
+    String baseUrl;
+    
+    @Autowired
+    public SecurityConfig(TokenProvider tokenProvider, SamlSuccessHandler samlSuccessHandler, SamlFailureHandler samlFailureHandler) {
+        this.tokenProvider = tokenProvider;
+        this.samlSuccessHandler =samlSuccessHandler;
+        this.samlFailureHandler=samlFailureHandler;
+    }
+    
+
+    @Bean
+    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
+        return config.getAuthenticationManager();
+    }
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+    @Bean
+    public MvcRequestMatcher.Builder mvc(HandlerMappingIntrospector introspector) {
+        return new MvcRequestMatcher.Builder(introspector);
+    }
+
+    @Bean
+    public WebSecurityCustomizer webSecurityCustomizer(MvcRequestMatcher.Builder mvc) {
+        return (web) -> web.ignoring().requestMatchers(mvc.pattern(HttpMethod.OPTIONS, "/**"))
+                .requestMatchers(new AntPathRequestMatcher("/i18n/**"))
+                .requestMatchers(new AntPathRequestMatcher("/content/**"))
+                .requestMatchers(new AntPathRequestMatcher("/swagger-ui/index.html"))
+                .requestMatchers(new AntPathRequestMatcher("/swagger-ui/**"));
+    }
+
+    
+    @Bean
+    public CorsFilter corsFilter() {
+
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+
+        CorsConfiguration config = new CorsConfiguration();
+        config.addAllowedOrigin("*");
+        config.addAllowedMethod("*");
+        config.addAllowedHeader("*");
+        config.setMaxAge(3600l);
+
+        if (config.getAllowedOrigins() != null && !config.getAllowedOrigins().isEmpty()) {
+            source.registerCorsConfiguration("/v1/**", config);
+            source.registerCorsConfiguration("/management/**", config);
+            source.registerCorsConfiguration("/v1/api-docs", config);
+        }
+        return new CorsFilter(source);
+    }
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http.csrf(AbstractHttpConfigurer::disable).authorizeHttpRequests(auth -> auth
+                // Allow public access to the login endpoints
+                .requestMatchers("/v1/user/login").permitAll() // JWT-based login
+                .requestMatchers("/v1/user").permitAll() // User registration
+                .requestMatchers("/v1/user/sso/validate/existing-user/{token}").permitAll()
+                .requestMatchers("/v1/user/sso/validate/new-user/{token}").permitAll()
+                .requestMatchers("/v1/saml/**").permitAll() // JWT-based login
+                .requestMatchers("/saml2/**").permitAll() // SAML login initiation
+                .requestMatchers("/swagger-ui/**").permitAll() // Swagger docs
+                .requestMatchers("/v1/api-docs/**").permitAll() // API docs
+                .anyRequest().authenticated())
+                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+                .addFilterBefore(corsFilter(), UsernamePasswordAuthenticationFilter.class)
+                .addFilterBefore(new JWTFilter(tokenProvider), UsernamePasswordAuthenticationFilter.class)
+                // Add SAML2 login configuration (for BENEFICIARI)
+                /*
+                 * .saml2Login(saml -> saml.loginPage("/saml/login") // Entry point for SAML
+                 * login .defaultSuccessUrl("/") // Redirect after successful SAML login );
+                 */
+				.saml2Login(saml -> saml.defaultSuccessUrl("/").successHandler(samlSuccessHandler)
+						.failureHandler(samlFailureHandler));
+
+
+        return http.build();
+    }
+
+    @Bean
+    public OpenAPI customOpenAPI() {
+        return new OpenAPI()
+                .addServersItem(new Server().url("/"))
+                .addSecurityItem(new SecurityRequirement().addList("bearer-key"))
+                .components(new Components().addSecuritySchemes("bearer-key",
+                        new SecurityScheme().type(SecurityScheme.Type.HTTP)
+                                .scheme("bearer").bearerFormat("JWT")));
+    }
+    
+   
+}

src/main/java/net/gepafin/tendermanagement/config/Translator.java

@@ -0,0 +1,30 @@
+package net.gepafin.tendermanagement.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.context.support.ResourceBundleMessageSource;
+import org.springframework.stereotype.Component;
+
+import java.util.Locale;
+
+@Component
+public class Translator {
+
+   private static ResourceBundleMessageSource messageSource;
+
+   @Autowired
+   Translator(ResourceBundleMessageSource messageSource) {
+      Translator.messageSource = messageSource;
+   }
+
+   public static String toLocale(String msgCode) {
+//      LocaleContextHolder.setDefaultLocale(Locale.ITALIAN);
+      Locale locale = LocaleContextHolder.getLocale();
+      return messageSource.getMessage(msgCode, null, locale);
+   }
+
+   public static String toLocale(String key, Object... args) {
+      return messageSource.getMessage(key, args, LocaleContextHolder.getLocale());
+   }
+
+}

src/main/java/net/gepafin/tendermanagement/config/jwt/JWTConfigurer.java

@@ -0,0 +1,23 @@
+package net.gepafin.tendermanagement.config.jwt;
+
+import org.springframework.security.config.annotation.SecurityConfigurerAdapter;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.web.DefaultSecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+public class JWTConfigurer extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {
+
+    public static final String AUTHORIZATION_HEADER = "Authorization";
+
+    private TokenProvider tokenProvider;
+
+    public JWTConfigurer(TokenProvider tokenProvider) {
+        this.tokenProvider = tokenProvider;
+    }
+
+    @Override
+    public void configure(HttpSecurity http) throws Exception {
+        JWTFilter customFilter = new JWTFilter(tokenProvider);
+        http.addFilterBefore(customFilter, UsernamePasswordAuthenticationFilter.class);
+    }
+}

src/main/java/net/gepafin/tendermanagement/config/jwt/JWTFilter.java

@@ -0,0 +1,43 @@
+package net.gepafin.tendermanagement.config.jwt;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.util.StringUtils;
+import org.springframework.web.filter.GenericFilterBean;
+
+import java.io.IOException;
+
+public class JWTFilter extends GenericFilterBean {
+
+    private final TokenProvider tokenProvider;
+
+    public JWTFilter(TokenProvider tokenProvider) {
+        this.tokenProvider = tokenProvider;
+    }
+
+    @Override
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
+            throws IOException, ServletException {
+        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
+        String token = resolveToken(httpServletRequest);
+
+        if (StringUtils.hasText(token) && tokenProvider.validateToken(token)) {
+            Authentication authentication = tokenProvider.getAuthentication(token);
+            if (authentication != null) {
+                SecurityContextHolder.getContext().setAuthentication(authentication);
+            }
+        }
+
+        filterChain.doFilter(servletRequest, servletResponse);
+    }
+
+    private String resolveToken(HttpServletRequest request) {
+        String bearerToken = request.getHeader("Authorization");
+        return StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ") ? bearerToken.substring(7) : null;
+    }
+}

src/main/java/net/gepafin/tendermanagement/config/jwt/TokenProvider.java

@@ -0,0 +1,248 @@
+package net.gepafin.tendermanagement.config.jwt;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.security.Keys;
+import jakarta.annotation.PostConstruct;
+import jakarta.servlet.http.HttpServletRequest;
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.UserEntity;
+import net.gepafin.tendermanagement.repositories.UserRepository;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import net.gepafin.tendermanagement.web.rest.api.errors.UnauthorizedAccessException;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.time.DateUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import javax.crypto.SecretKey;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.stream.Collectors;
+import com.google.gson.Gson;
+
+import static io.micrometer.common.util.StringUtils.isEmpty;
+
+
+@Component
+public class TokenProvider {
+    private final Logger log = LoggerFactory.getLogger(TokenProvider.class);
+
+    @Value("${security.authentication.jwt.secret}")
+    private String secretKey;
+
+    @Value("${security.authentication.jwt.token-validity-in-seconds}")
+    private long tokenValidityInSeconds;
+    @Autowired
+    private UserRepository userRepository;
+
+    private SecretKey key;
+
+    private static final String AUTHORITIES_KEY = "auth";
+    private static final String MERCHANTID="merchantId";
+
+    static final  String AUTH_SECRET = "X-Api-Secret";
+    private final Set<String> invalidatedTokens = new HashSet<>();
+    private static final String USER_ID = "userId";
+
+        public UserEntity validateUser(Map<String, Object> userInfo) {
+        if (userInfo == null || userInfo.get(USER_ID) == null) {
+            throw new UnauthorizedAccessException(Status.UNAUTHORIZED, Translator.toLocale(GepafinConstant.INVALID_USER));
+        }
+
+        Long userId = Long.valueOf(userInfo.get(USER_ID).toString());
+        UserEntity userEntity = userRepository.findById(userId).orElse(null);
+
+        if (userEntity == null) {
+            throw new UnauthorizedAccessException(Status.UNAUTHORIZED, Translator.toLocale(GepafinConstant.INVALID_USER));
+        }
+
+        if (!userEntity.getStatus().equals("ACTIVE")) {
+            throw new UnauthorizedAccessException(Status.UNAUTHORIZED, Translator.toLocale(GepafinConstant.INVALID_USER));
+        }
+
+        return userEntity;
+    }
+    @PostConstruct
+    public void init() {
+        this.key = Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8));
+        log.info("JWT Secret Key initialized.");
+    }
+
+    public String createToken(Boolean rememberMe, UserEntity user) {
+//        String authorities = authentication.getAuthorities().stream()
+//                .map(GrantedAuthority::getAuthority)
+//                .collect(Collectors.joining(","));
+    	String authorities = user.getRoleEntity().getRoleType();
+        Long now;
+        Date validity;
+
+        if (Boolean.TRUE.equals(rememberMe)) {
+            now = DateUtils.addMonths(new Date(), 2).getTime();
+            validity = new Date(now);
+            log.info("Creating token with extended validity for 2 months.");
+        } else {
+            now = (new Date()).getTime();
+            validity = new Date(now + (this.tokenValidityInSeconds * 1000));
+            log.info("Creating token with standard validity of {} seconds.", this.tokenValidityInSeconds);
+        }
+
+        String payload = user.getEmail();
+        if(user != null) {
+            payload += ":"+user.getId();
+        }
+
+        String token = Jwts.builder()
+                .setSubject(payload)
+                .claim("auth", authorities)
+                .signWith(key, SignatureAlgorithm.HS512)
+                .setExpiration(validity)
+                .compact();
+
+        log.debug("Generated token: {}", token);
+        return token;
+    }
+
+    public Authentication getAuthentication(String token) {
+        Claims claims = Jwts.parserBuilder()
+                .setSigningKey(key)
+                .build()
+                .parseClaimsJws(token)
+                .getBody();
+
+        UserDetails principal = new User(claims.getSubject(), "", Collections.emptyList());
+        log.info("Authenticated user: {}", claims.getSubject());
+
+        return new UsernamePasswordAuthenticationToken(principal, token, ClaimsToAuthorities(claims.get("auth")));
+    }
+
+    private Collection<? extends GrantedAuthority> ClaimsToAuthorities(Object authClaim) {
+        Collection<? extends GrantedAuthority> authorities = authClaim == null || ((String) authClaim).isEmpty() ?
+                Collections.emptyList() :
+                Arrays.stream(((String) authClaim).split(","))
+                        .map(SimpleGrantedAuthority::new)
+                        .collect(Collectors.toList());
+        log.debug("Converted authorities from claims: {}", authorities);
+        return authorities;
+    }
+
+    public boolean validateToken(String authToken) {
+        try {
+            if (isTokenInvalid(authToken)) {
+                log.warn("Token is invalidated.");
+                return false;
+            }
+            Jwts.parserBuilder()
+                    .setSigningKey(key)
+                    .build()
+                    .parseClaimsJws(authToken);
+            log.info("Token is valid.");
+            return true;
+        } catch (Exception e) {
+            log.error("Token validation failed: {}", e.getMessage());
+            return false;
+        }
+    }
+
+    public void invalidateToken(String token) {
+        invalidatedTokens.add(token);
+        log.info("Token invalidated: {}", token);
+    }
+
+    public boolean isTokenInvalid(String token) {
+        return invalidatedTokens.contains(token);
+    }
+    public Map<String, Object> getUserInfoAndUserIdFromToken(HttpServletRequest request) {
+        Map<String, Object> userInfo = new HashMap<>();
+        String authSecretHeader=request.getHeader(AUTH_SECRET);
+//        userInfo.put(MERCHANTID, null);
+        String bearerToken = request.getHeader("Authorization");
+        String token = "";
+        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
+            token = bearerToken.substring(7, bearerToken.length());
+        }
+        extractDetailsFromTheToken(userInfo, authSecretHeader, token);
+        return userInfo;
+    }
+    public Map<String, Object> extractDetailsFromTheToken(Map<String, Object> userInfo, String authSecretHeader,
+                                                          String token) {
+        String payload = null;
+        Boolean isSuperAdmin = false;
+//        if (StringUtils.hasText(token) && token.endsWith("_superKey" + getSuperUserToken())) {
+//            Map<String, Object> payloadMap = getUserDetailsForSuperUser(token);
+//            payload = payloadMap.get("sub").toString();
+//            isSuperAdmin = true;
+//
+//        } else
+        if (!isEmpty(authSecretHeader)) {
+            String secret = Utils.decodeBase64String(authSecretHeader);
+            String[] tokenArr = secret.split("\\.", 2);
+            String[] merchant = tokenArr[0].split("-");
+            if (ArrayUtils.isNotEmpty(merchant) && 2 <= merchant.length) {
+                userInfo.put(MERCHANTID, merchant[1]);
+                return userInfo;
+            }
+
+        } else {
+            payload = getUserDetails(token);
+        }
+        if (payload != null && !isSuperAdmin) {
+            String[] payloadString = payload.split(":");{
+
+                if (payloadString.length > 1) {
+//                userInfo.put(MERCHANTID, payloadString[1]);
+//                userInfo.put("associatedTags", payloadString[2]);
+                    userInfo.put("userId", payloadString[1]);
+                }
+            }
+
+            if (payloadString.length > 1) {
+//                userInfo.put(MERCHANTID, payloadString[1]);
+//                userInfo.put("associatedTags", payloadString[2]);
+                userInfo.put("userId", payloadString[1]);
+            }
+        } else {
+            String[] payloadString = payload.split(":");
+
+            if (payloadString.length > 1) {
+                userInfo.put("userId", payloadString[1]);
+            }
+        }
+
+        return userInfo;
+    }
+    public Map<String, Object> getUserDetailsForSuperUser(String token) {
+        Base64.Decoder decoder = Base64.getUrlDecoder();
+        String[] parts = token.split("\\."); // Splitting header, payload and signature
+        Gson g = new Gson();
+        return g.fromJson(new String(decoder.decode(parts[1])), Map.class);
+    }
+    //    public String getSuperUserToken() {
+//        return superUserToken;
+//    }
+    public String getUserDetails(String token) {
+        Claims claims = Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
+        return claims.getSubject();
+    }
+    public String extractTokenFromRequest(HttpServletRequest request) {
+        String bearerToken = request.getHeader("Authorization");
+        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
+            return bearerToken.substring(7); // Remove "Bearer " prefix
+        }
+        return null; // Return null if token is not found or not in Bearer format
+    }
+
+}

src/main/java/net/gepafin/tendermanagement/constants/GepafinConstant.java

@@ -0,0 +1,170 @@
+package net.gepafin.tendermanagement.constants;
+
+public class GepafinConstant {
+
+    public static final String USER_CREATED_SUCCESS_MSG = "user.created.success";
+    public static final String USER_UPDATED_SUCCESS_MSG = "user.updated.success";
+    public static final String USER_DELETED_SUCCESS_MSG = "user.deleted.success";
+    public static final String USER_NOT_FOUND_MSG = "user.not.found";
+    public static final String CREATE_USER_ERROR_MSG = "create_user_error_msg";
+    public static final String UPDATE_USER_ERROR_MSG = "update_user_error_msg";
+    public static final String DELETE_USER_ERROR_MSG = "delete_user_error_msg";
+    public static final String GET_USER_SUCCESS_MSG = "get_user_success_msg";
+    public static final String USER_NOT_ACTIVE_MSG = "user.not.active";
+
+    public static final String ROLE_CREATED_SUCCESS_MSG = "role.created.success";
+    public static final String ROLE_UPDATED_SUCCESS_MSG = "role.updated.success";
+    public static final String ROLE_DELETED_SUCCESS_MSG = "role.deleted.success";
+    public static final String ROLE_FETCH_SUCCESS_MSG = "role.fetch.success";
+    public static final String ROLE_NOT_FOUND = "role.not.found";
+
+    public static final String VALUE_CANNOT_BE_EMPTY = "lookupdata.value.cannot.be.empty";
+    public static final String REGION_CREATED_SUCCESS_MSG = "region.created.success";
+    public static final String REGION_UPDATED_SUCCESS_MSG = "region.updated.success";
+    public static final String GET_REGION_SUCCESS_MSG = "get.region.success";
+    public static final String DELETE_REGION_SUCCESS_MSG = "delete.region.success";
+    public static final String REGION_NOT_FOUND_MSG = "user.region.not.found";
+    public static final String PASSWORD_DOESNT_MATCH ="password.doesnt.match";
+    public static final String USER_NOT_EXIST_MSG = "user.not.exist";
+    public static final String REGION_NOT_FOUND = "region.not.found";
+    public static final String USER_ID_NOT_NULL_MSG = "user.id.not.null";
+    public static final String QUESTION_NOT_EMPTY_MSG = "question.not.empty";
+    public static final String NAME_NOT_EMPTY_MSG = "name.not.empty";
+    public static final String TYPE_NOT_EMPTY_MSG = "type.not.empty";
+    public static final String REGION_NOT_NULL_MSG = "region.not.null";
+    public static final String AMOUNT_GREATER_THAN_ZERO_MSG = "amount.greater.than.zero";
+    public static final String LOOK_UP_DATA_NOT_VALID_MSG = "look.up.data.not.valid";
+    public static final String FILES_UPLOADED_MSG = "files.uploaded";
+    public static final String CALL_CREATED_SUCCESSFULLY_MSG = "call.created.successfully";
+    public static final String FILE_DELETED_SUCCESSFULLY_MSG="file.deleted.successfully";
+    public static final String DOCUMENT_NOT_FOUND="document.not.found";
+    public static final String LOGIN_SUCCESS_MSG="login.successfully";
+    public static final String PASSWORD_MIN_LEN ="pass.min.len.msg";
+    public static final String EMAIL_ALREADY_EXISTS = "email.already.exists";
+    public static final String DOCUMENT_ID_NOT_FOUND="document.id.not.found";
+	public static final String INVALID_DATE_MSG = "call.invalid.date";
+    public static final String FORM_NOT_FOUND = "form.not.found";
+    public static final String FORM_CREATED_SUCCESSFULLY = "form.created.successfully";
+    public static final String FORM_UPDATED_SUCCESSFULLY = "form.updated.suucessfully";
+    public static final String FORM_DELETED_SUCCESSFULLY = "form.deleted.successfully";
+    public static final String FORM_FETCHED_SUCCESSFULLY = "form.fetched.successfully";
+    public static final String REQUIRED_PARAMETER_NOT_FOUND_FOR_FORM = "required.parameter.not.found.for.form";
+    public static final String FORM_FIELD_NOT_FOUND = "form.field.not.found";
+    public static final String FORM_FIELD_CREATED_SUCCESSFULLY = "form.field.created.successfully";
+    public static final String FORM_FIELD_UPDATED_SUCCESSFULLY = "form.field.updated.suucessfully";
+    public static final String FORM_FIELD_DELETED_SUCCESSFULLY = "form.field.deleted.successfully";
+    public static final String FORM_FIELD_FETCHED_SUCCESSFULLY = "form.field.fetched.successfully";
+    public static final String REQUIRED_PARAMETER_NOT_FOUND_FOR_FORM_FIELD = "required.parameter.not.found.for.form.field";
+    public static final String FORM_TEMPLATE_NOT_FOUND = "form.template.not.found";
+    public static final String FORM_TEMPLATE_CREATED_SUCCESSFULLY = "form.template.created.successfully";
+    public static final String FORM_TEMPLATE_UPDATED_SUCCESSFULLY = "form.template.updated.suucessfully";
+    public static final String FORM_TEMPLATE_DELETED_SUCCESSFULLY = "form.template.deleted.successfully";
+    public static final String FORM_TEMPLATE_FETCHED_SUCCESSFULLY = "form.template.fetched.successfully";
+    public static final String REQUIRED_PARAMETER_NOT_FOUND_FOR_FORM_TEMPLATE = "required.parameter.not.found.for.form.template";
+    public static final String FORM_NOT_FOUND_FOR_CALL_ID="form.not.found.for.call.id";
+	public static final String STEP_1 = "STEP_1";
+	public static final String STEP_2 = "STEP_2";
+	public static final String VALIDATE_REQUEST = "VALIDATE_REQUEST";
+	public static final String CALL_UPDATE_SUCCESSFULLY_MSG = "call.update.successfully";
+	public static final String CALL_NOT_FOUND = "call.not.found";
+    public static final String CALL_FETCH_SUCCESS_MSG = "call.fetch.success";
+
+    public static final String EVALUATION_CRITERIA_NOT_FOUND = "evaluation.criteria.not.found";
+    public static final String EVALUATION_CRITERIA_CREATED_SUCCESSFULLY = "evaluation.criteria.created.successfully";
+    public static final String EVALUATION_CRITERIA_FETCH_SUCCESSFULLY = "evaluation.criteria.fetch.successfully";
+    public static final String EVALUATION_CRITERIA_UPDATED_SUCCESSFULLY = "evaluation.criteria.updated.successfully";
+    public static final String EVALUATION_CRITERIA_DELETED_SUCCESSFULLY = "evaluation.criteria.deleted.successfully";
+    public static final String SCORE_NOT_NULL_MSG="score.not.null";
+    public static final String FAQ_NOT_FOUND = "faq.not.found";
+    public static final String FAQ_CREATED_SUCCESSFULLY = "faq.created.successfully";
+    public static final String FAQ_FETCHED_SUCCESSFULLY = "faq.fetched.successfully";
+    public static final String FAQ_UPDATED_SUCCESSFULLY = "faq.updated.successfully";
+    public static final String FAQ_DELETED_SUCCESSFULLY = "faq.deleted.successfully";
+    public static final String LOOKUP_DATA_NOT_FOUND = "lookupdata.not.found";
+    public static final String LOOKUP_DATA_CREATED_SUCCESSFULLY = "lookupdata.created.successfully";
+    public static final String LOOKUP_DATA_FETCHED_SUCCESSFULLY = "lookupdata.fetched.successfully";
+    public static final String LOOKUP_DATA_UPDATED_SUCCESSFULLY = "lookupdata.updated.successfully";
+    public static final String LOOKUP_DATA_DELETED_SUCCESSFULLY = "lookupdata.deleted.successfully";
+    public static final String DOCUMENT_UPDATED_SUCCESSFULLY = "document.updated.successfully";
+    public static final String DOCUMENT_FETCHED_SUCCESSFULLY = "document.fetched.successfully";
+    public static final String RESET_PASSWORD_INITIATED = "password.reset.initiated";
+    public static final String PASSWORD_RESET_SUCCESS = "password.reset.success";
+    public static final String INVALID_TOKEN_MSG = "invalid.token.msg";
+    public static final String CURRENT_PASSWORD_INCORRECT = "current.password.incorrect";
+
+    public static final String LOGOUT_SUCCESSFUL_MSG = "logout.successful.msg";
+    public static final String SUCCESS_PASSWORD_CHANGED = "success.password.changed";
+    public static final String UPDATE_USER_STATUS_SUCCESS_MSG = "update.user.status.success";
+    public static final String FIELD_NOT_NULL = "field.not.null";
+    public static final String FIELD_NOT_EMPTY = "field.not.empty";
+    public static final String UPDATE_CALL_STATUS_SUCCESS_MSG = "update_call_status_success_msg";
+    public static final String STATUS_SAME_ERROR = "status.same.error";
+    public static final String INVALID_STATUS_CHANGE_FROM_DRAFT = "invalid.status.change.from.draft";
+    public static final String INVALID_STATUS_CHANGE_FROM_PUBLISH = "invalid.status.change.from.publish";
+    public static final String STATUS_CANNOT_BE_CHANGED = "status.cannot.be.changed";
+	public static final String PUBLISHED_CALL_NOT_UPDATE = "published.call.not.update";
+    public static final String INVALID_USER = "invalid_user";
+    public static final String FLOW_CREATED_SUCCESSFULLY="flow.created.successfully";
+    public static final String FLOW_FETCHED_SUCCESSFULLY="flow.fetched.successfully";
+    public static final String FLOW_ALREADY_EXISTS="flow.already.exists";
+    public static final String FLOW_REQUEST_NOT_PROPER="flow.request.not.complete";
+    public static final String APPLICATION_CREATED_SUCCESS_MSG = "application.created.success";
+    public static final String APPLICATION_UPDATED_SUCCESS_MSG = "application.updated.success";
+    public static final String DELETE_APPLICATION_SUCCESS_MSG = "application.deleted.success";
+    public static final String GET_APPLICATION_SUCCESS_MSG = "application.get.success";
+    public static final String APPLICATION_NOT_FOUND_MSG = "application.not.found";
+    public static final String APPLICATION_FORM_FIELD_NOT_FOUND="application.form.field.not.found";
+    public static final String FORM_ID_DOES_NOT_MACTHES="Form.not.matches.to.call.initial.form";
+    public static final String VALIDATION_FIELD_REQUIRED = "validation.field.required";
+    public static final String VALIDATION_FIELD_MIN_LENGTH = "validation.field.min_length";
+    public static final String VALIDATION_FIELD_MAX_LENGTH = "validation.field.max_length";
+    public static final String VALIDATION_FIELD_PATTERN = "validation.field.pattern";
+    public static final String VALIDATION_FIELD_NOT_NULL = "validation.field.not_null";
+    public static final String VALIDATION_FIELD_NOT_EMPTY = "validation.field.not_empty";
+    public static final String APPLICATION_ALREADY_EXISTS="application.already.exists";
+	// public static final String NEXT_FORM_NOT_FOUND = "next.form.not.found";
+	// public static final String PREVIOUS_FORM_NOT_FOUND = "previous.form.not.found";
+	public static final String CURRENT_FORM_INCOMPLETE = "current.form.incomplete";
+    public static final String FLOW_NOT_FOUND = "flow.not.found";
+	public static final String VALIDATION_MESSAGE = "validation.message";
+	public static final String ACTION_REQUIRED = "action.required";
+    public static final String CALL_NOT_PUBLISHED="call.not.published";
+    public static final String APPLICATION_ALREADY_SUBMITTED="application.already.submitted";
+    public static final String INITAL_AND_FINAL_FORM_CANNOT_NULL="initial.and.final.form.cannot.null";
+    public static final String APPLICATION_FORM_NOT_FOUND="application.form.not.found";
+    public static final String UPDATING_FORM_VALUE_IMPACT_ON_FLOW="updating.form.value.impact.on.flow";
+    public static final String APPLICATION_IS_INCOMPLETE_MSG = "application.is.incomplete";
+    public static final String AUTHORIZATION = "Authorization";
+    public static final String CHECK_VATNUMBER_V2_NEW_URL = "https://imprese.openapi.it/advance";
+    public static final String VATNUMBER_V2 = "https://imprese.openapi.it/advance";
+    public static final String VALIDATION_FIELD_CUSTOM="validation.field.custom";
+    public static final String VALIDATION_CODICE_FISCALE = "validation.codice.fiscale";
+    public static final String VALIDATION_CAP = "validation.cap";
+    public static final String VALIDATION_IBAN = "validation.iban";
+    public static final String VALIDATION_EMAIL = "validation.email";
+    public static final String VALIDATION_EMAIL_PEC = "validation.email.pec";
+    public static final String VALIDATION_URL = "validation.url";
+    public static final String VALIDATION_MARCA_DA_BOLLO = "validation.marca.da.bollo";
+    public static final String VALIDATION_PIVA = "validation.piva";
+    public static final String VALIDATION_VALID_PIVA="valid.vat.number";
+    public static final String IS_MARCA_DA_BOLLO="isMarcaDaBollo";
+    public static final String IS_URL="isUrl";
+    public static final String IS_EMAIL_PEC="isEmailPEC";
+    public static final String IS_EMAIL="isEmail";
+    public static final String IS_IBAN="isIBAN";
+    public static final String IS_CAP="isCAP";
+    public static final String IS_CODICE_FISCALE="isCodiceFiscale";
+    public static final String IS_PIVA="isPIVA";
+    public static final String FAILED_RETAIN_FIELD="failed.retain.field";
+	public static final String USER_ALREADY_EXIST_MSG = "user.already.exist.msg";
+	public static final String TOKEN_VALIDATE_SUCCESS_MSE = "token.validate.success";
+	public static final String INVALID_REQUEST = "invalid.request";
+	public static final String CODICE_FISCALE_EXISTS = "codice.fiscale.exists";
+    public static final String TOTAL_STEPS_NOT_BE_ZERO="total.steps.not.zero";
+    public static final String COMPLETED_STEPS_NOT_VALID="completed.steps.not.valid";
+    public static final String FIELD_ID_NOT_FOUND="field.id.not.found";
+	public static final String VALIDATE_EMAIL = "validate.email";
+	public static final String ROLE_ID_MANDATORY = "role.id.mandatory";
+	public static final String VALIDATE_PASSWORD = "validate.password";
+	
+}

src/main/java/net/gepafin/tendermanagement/dao/ApplicationDao.java

@@ -0,0 +1,563 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.*;
+import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum;
+import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum;
+import net.gepafin.tendermanagement.enums.RoleStatusEnum;
+import net.gepafin.tendermanagement.model.request.ApplicationFormFieldRequestBean;
+import net.gepafin.tendermanagement.model.request.ApplicationRequest;
+import net.gepafin.tendermanagement.model.request.ApplicationRequestBean;
+import net.gepafin.tendermanagement.model.response.*;
+import net.gepafin.tendermanagement.repositories.*;
+import net.gepafin.tendermanagement.service.CallService;
+import net.gepafin.tendermanagement.service.DocumentService;
+import net.gepafin.tendermanagement.service.FormService;
+import net.gepafin.tendermanagement.util.DateTimeUtil;
+import net.gepafin.tendermanagement.util.FieldValidator;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.checkerframework.checker.units.qual.A;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.text.MessageFormat;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Component
+public class ApplicationDao {
+
+    private final Logger log = LoggerFactory.getLogger(ApplicationDao.class);
+
+    @Autowired
+    private CallService callService;
+
+    @Autowired
+    private ApplicationRepository applicationRepository;
+
+    @Autowired
+    private ApplicationFormRepository applicationFormRepository;
+
+    @Autowired
+    private ApplicationFormFieldRepository applicationFormFieldRepository;
+
+    @Autowired
+    private FormService formService;
+
+    @Autowired
+    private DocumentService documentService;
+
+    @Autowired
+    private CallDao callDao;
+
+    @Autowired
+    private FlowFormDao flowFormDao;
+
+    @Autowired
+    private FlowEdgesRepository flowEdgesRepository;
+
+    @Autowired
+    private FlowDataRepository flowDataRepository;
+
+
+    public ApplicationResponseBean createApplication(ApplicationRequestBean applicationRequestBean, UserEntity userEntity, Long formId,Long applicationId) {
+        FormEntity formEntity = formService.validateForm(formId);
+        CallEntity call = callService.validatePublishedCall(formEntity.getCall().getId());
+        validateFormFields(applicationRequestBean,formEntity);
+        ApplicationEntity applicationEntity = validateApplication(applicationId);
+        if(Boolean.TRUE.equals(applicationEntity.getStatus().equals(ApplicationStatusTypeEnum.SUBMIT.getValue()))){
+            throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.APPLICATION_ALREADY_SUBMITTED));
+        }
+        formService.validateFormField(applicationRequestBean.getFormFields(),applicationEntity,formEntity);
+        ApplicationFormEntity applicationFormEntity =  getApplicationFormOrCreate(formEntity, applicationEntity);
+        createOrUpdateMultipleFormFields(applicationRequestBean.getFormFields(), applicationFormEntity,formEntity);
+        return getApplicationById(applicationEntity.getId(),formEntity.getId());
+    }
+
+    public ApplicationFormEntity saveApplicationFormEntity(ApplicationFormEntity applicationFormEntity) {
+        ApplicationFormEntity applicationFormEntity1 = applicationFormRepository.save(applicationFormEntity);
+        return applicationFormEntity1;
+    }
+
+    public ApplicationFormEntity createApplicationFormEntity(ApplicationEntity application, FormEntity formEntity) {
+        ApplicationFormEntity applicationFormEntity = new ApplicationFormEntity();
+        applicationFormEntity.setApplication(application);
+        applicationFormEntity.setForm(formEntity);
+        applicationFormEntity = saveApplicationFormEntity(applicationFormEntity);
+        return applicationFormEntity;
+    }
+
+    public ApplicationEntity createApplicationEntity(UserEntity user, CallEntity call) {
+        ApplicationEntity entity = new ApplicationEntity();
+        entity.setUser(user);
+        entity.setCall(call);
+        entity.setIsDeleted(false);
+        entity.setStatus(ApplicationStatusTypeEnum.DRAFT.getValue());
+        return entity;
+    }
+
+    public ApplicationResponseBean getApplicationById(Long id,Long formId) {
+        log.info("Fetching application with ID: {}", id);
+
+        ApplicationEntity applicationEntity = validateApplication(id);
+       ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(),formId);
+        List<ApplicationFormFieldResponseBean> applicationFormFieldResponseBeans=new ArrayList<>();
+        ApplicationFormFieldResponseBean applicationFormFieldResponseBeans1=null;
+        List<ApplicationFormFieldEntity> applicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId());
+        applicationFormFieldResponseBeans=createApplicationFormFieldResponse(applicationFormFieldEntities, applicationFormEntity, applicationFormFieldResponseBeans);
+        ApplicationResponseBean applicationResponseBean= convertApplicationEntityToApplicationResponseBean(applicationEntity);
+        applicationResponseBean.setFormFields(applicationFormFieldResponseBeans);
+        return applicationResponseBean;
+    }
+
+    private List<ApplicationFormFieldResponseBean> createApplicationFormFieldResponse(
+            List<ApplicationFormFieldEntity> applicationFormFieldEntities,
+            ApplicationFormEntity applicationFormEntity,
+            List<ApplicationFormFieldResponseBean> applicationFormFieldResponseBeans) {
+
+        List<ContentResponseBean> contentResponseBeans = Utils.convertJsonStringToList(
+                applicationFormEntity.getForm().getContent(), ContentResponseBean.class);
+
+        for (ApplicationFormFieldEntity applicationFormFieldEntity : applicationFormFieldEntities) {
+
+            Optional<ContentResponseBean> fileUploadContent = contentResponseBeans.stream()
+                    .filter(contentResponseBean -> "fileupload".equals(contentResponseBean.getName()) &&
+                            contentResponseBean.getId().equals(applicationFormFieldEntity.getFieldId()))
+                    .findFirst();
+
+            List<DocumentResponseBean> documentResponseBeans = new ArrayList<>();
+            if (fileUploadContent.isPresent()) {
+                String documentId = applicationFormFieldEntity.getFieldValue();
+                if (documentId != null && !documentId.isEmpty()) {
+                    documentResponseBeans = Arrays.stream(documentId.split(","))
+                            .map(String::trim)
+                            .map(Long::parseLong)
+                            .map(docId -> {
+                                DocumentEntity documentEntity = documentService.validateDocument(docId);
+                                if (Boolean.FALSE.equals(DocumentSourceTypeEnum.APPLICATION.getValue().equals(documentEntity.getSource()))) {
+                                    throw new CustomValidationException(Status.NOT_FOUND,Translator.toLocale(GepafinConstant.DOCUMENT_NOT_FOUND));
+                                }
+                                return documentEntity;
+                            })
+                            .map(callDao::convertToDocumentResponseBean)
+                            .collect(Collectors.toList());
+                }
+            }
+            ApplicationFormFieldResponseBean responseBean = convertApplicationFormFieldEntityToApplicationFormFieldResponseBean(
+                    applicationFormFieldEntity, applicationFormEntity.getId());
+            if (!documentResponseBeans.isEmpty()) {
+                responseBean.setFieldValue(documentResponseBeans);
+            }
+            applicationFormFieldResponseBeans.add(responseBean);
+        }
+
+        return applicationFormFieldResponseBeans;
+    }
+
+    public void deleteById(Long id) {
+        log.info("Deleting application with ID: {}", id);
+
+        ApplicationEntity applicationEntity= validateApplication(id);
+        applicationEntity.setIsDeleted(true);
+        applicationEntity=saveApplicationEntity(applicationEntity);
+        log.info("Application deleted with ID: {}", id);
+    }
+
+    public List<ApplicationResponse> getAllApplications(UserEntity userEntity, Long callId) {
+        boolean isBeneficiary = isBeneficiary(userEntity);
+        
+        log.info("Fetching applications for RoleType: {}", userEntity.getRoleEntity().getRoleType());
+        List<ApplicationResponse> applicationResponses = new ArrayList<>();
+
+        if (callId != null) {
+            // Fetch based on callId and user if role is BENEFICIARY, otherwise fetch all for the call
+            log.info("Fetching applications for callId: {}", callId);
+            CallEntity call = callService.validateCall(callId);
+
+            // Use a single method to handle both conditions for consistency
+            List<ApplicationEntity> applicationEntities = isBeneficiary
+                    ? applicationRepository.findByUserIdAndCallIdAndIsDeletedFalse(userEntity.getId(), call.getId())
+                            .map(List::of) // Convert Optional<ApplicationEntity> to a List of one element
+                            .orElse(List.of()) // If not present, return an empty list
+                    : applicationRepository.findByCallIdAndIsDeletedFalse(call.getId());
+
+            applicationResponses = applicationEntities.stream()
+                    .map(this::getApplicationResponse)
+                    .collect(Collectors.toList());
+
+        } else {
+            // Fetch all applications for the user if BENEFICIARY, or fetch all applications in general
+            List<ApplicationEntity> applicationEntities = isBeneficiary
+                    ? applicationRepository.findByUserIdAndIsDeletedFalse(userEntity.getId())
+                    : applicationRepository.findByIsDeletedFalse();
+
+            applicationResponses = applicationEntities.stream()
+                    .map(this::getApplicationResponse)
+                    .collect(Collectors.toList());
+        }
+
+        return applicationResponses;
+    }
+
+
+    private ApplicationResponse getApplicationResponse(ApplicationEntity applicationEntity) {
+        ApplicationResponse responseBean = new ApplicationResponse();
+        List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByCallId(applicationEntity.getCall().getId());
+        Long totalFormSteps = flowFormDao.calculateTotalSteps(flowEdgesList);
+        Long completedSteps= Long.valueOf(flowFormDao.getCompletedSteps(applicationEntity));
+        Integer progress=calculateProgress(totalFormSteps,completedSteps);
+        responseBean.setId(applicationEntity.getId());
+        responseBean.setProgress(progress);
+        responseBean.setCallTitle(applicationEntity.getCall().getName());
+        responseBean.setCallEndDate(applicationEntity.getCall().getEndDate());
+        responseBean.setModifiedDate(applicationEntity.getCall().getUpdatedDate());
+        responseBean.setCallId(applicationEntity.getCall().getId());
+        responseBean.setSubmissionDate(applicationEntity.getSubmissionDate());
+        responseBean.setStatus(applicationEntity.getStatus());
+        responseBean.setComments(applicationEntity.getComments());
+        return responseBean;
+    }
+
+    public ApplicationEntity validateApplication(Long id) {
+        ApplicationEntity applicationEntity= applicationRepository.findById(id).orElseThrow(() ->new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.APPLICATION_NOT_FOUND_MSG)));
+        return applicationEntity;
+    }
+
+    private ApplicationResponseBean convertApplicationEntityToApplicationResponseBean(ApplicationEntity entity) {
+        ApplicationResponseBean response = new ApplicationResponseBean();
+        response.setId(entity.getId());
+        response.setSubmissionDate(entity.getSubmissionDate());
+        response.setStatus(entity.getStatus());
+        response.setComments(entity.getComments());
+        response.setCallId(entity.getCall().getId());
+        response.setCreatedDate(entity.getCreatedDate());
+        response.setUpdatedDate(entity.getUpdatedDate());
+        return response;
+    }
+
+    private ApplicationFormEntity getApplicationFormOrCreate(FormEntity formEntity, ApplicationEntity applicationEntity) {
+        ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), formEntity.getId());
+        if(applicationFormEntity == null){
+            applicationFormEntity = createApplicationFormEntity(applicationEntity, formEntity);
+        }
+        return applicationFormEntity;
+    }
+
+    public List<ApplicationFormFieldEntity> createOrUpdateMultipleFormFields(List<ApplicationFormFieldRequestBean> formFieldResponseBeans, ApplicationFormEntity applicationFormEntity,FormEntity formEntity) {
+        List<ApplicationFormFieldEntity> existingFields = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId());
+
+        List<ApplicationFormFieldEntity> applicationFormFieldEntity = formFieldResponseBeans.stream()
+                .map(requestBean -> createOrUpdateApplicationFormField(requestBean, applicationFormEntity,existingFields,formEntity))
+                .collect(Collectors.toList());
+        return applicationFormFieldEntity;
+    }
+
+    public ApplicationFormFieldEntity createOrUpdateApplicationFormField(ApplicationFormFieldRequestBean applicationFormFieldRequestBean, ApplicationFormEntity applicationFormEntity,List<ApplicationFormFieldEntity> applicationFormFieldEntities ,FormEntity formEntity) {
+
+        ApplicationFormFieldEntity applicationFormFieldEntity=null;
+
+        validateFileUploadDocuments(applicationFormFieldRequestBean, formEntity);
+
+        if(applicationFormFieldEntities==null || applicationFormFieldEntities.isEmpty()){
+            applicationFormFieldEntity = new ApplicationFormFieldEntity();
+            applicationFormFieldEntity.setApplicationForm(applicationFormEntity);
+        }else {
+            for (ApplicationFormFieldEntity applicationFormFieldEntity1 : applicationFormFieldEntities) {
+                if (applicationFormFieldEntity1.getFieldId().equals(applicationFormFieldRequestBean.getFieldId())) {
+                    applicationFormFieldEntity = applicationFormFieldEntity1;
+                    if(applicationFormEntity.getForm().getId().equals(applicationFormEntity.getApplication().getCall().getInitialForm())){
+                        validateRequiredFields(applicationFormEntity.getForm(),applicationFormEntity.getApplication(), applicationFormFieldRequestBean.getFieldId());
+                    }
+                    break;
+                } else {
+                    applicationFormFieldEntity = new ApplicationFormFieldEntity();
+                    applicationFormFieldEntity.setApplicationForm(applicationFormEntity);
+                }
+            }
+        }
+        Utils.setIfUpdated(applicationFormFieldEntity::getFieldId, applicationFormFieldEntity::setFieldId, applicationFormFieldRequestBean.getFieldId());
+    if(applicationFormFieldRequestBean.getFieldValue() ==null ||  Boolean.FALSE.equals(applicationFormFieldRequestBean.getFieldValue().isEmpty())) {
+        applicationFormFieldEntity.setFieldValue(applicationFormFieldRequestBean.getFieldValue());
+    }
+        return applicationFormFieldRepository.save(applicationFormFieldEntity);
+    }
+
+    private List<Long> validateFileUploadDocuments(ApplicationFormFieldRequestBean applicationFormFieldRequestBean, FormEntity formEntity) {
+        List<Long> documentIds=null;
+        List<ContentResponseBean> contentResponseBeans=Utils.convertJsonStringToList(formEntity.getContent(),ContentResponseBean.class);
+        for (ContentResponseBean contentResponseBean:contentResponseBeans){
+            if(Boolean.TRUE.equals(contentResponseBean.getName().equals("fileupload"))){
+                if(contentResponseBean.getId().equals(applicationFormFieldRequestBean.getFieldId())) {
+                    String documentId = applicationFormFieldRequestBean.getFieldValue();
+                    documentIds = validateDocumentIds(documentId);
+                }
+            }
+        }
+        return documentIds;
+    }
+
+    private List<Long> validateDocumentIds(String documentId) {
+        if (documentId != null && !documentId.isEmpty()) {
+            return Arrays.stream(documentId.split(","))
+                    .map(Long::parseLong)
+                    .peek(docId -> documentService.validateDocument(docId))
+                    .collect(Collectors.toList());
+        }
+        return Collections.emptyList();
+    }
+
+
+    public ApplicationFormFieldEntity validateApplicationFormField(Long applicationFormFieldId) {
+        Optional<ApplicationFormFieldEntity> applicationFormFieldEntity = applicationFormFieldRepository.findById(applicationFormFieldId);
+        if (applicationFormFieldEntity.isEmpty()) {
+            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.APPLICATION_FORM_FIELD_NOT_FOUND));
+        }
+        return applicationFormFieldEntity.get();
+    }
+
+    public List<ApplicationFormFieldEntity> saveApplicationFormFieldEntities(List<ApplicationFormFieldEntity> applicationFormFieldEntities) {
+        List<ApplicationFormFieldEntity> applicationFormFieldEntities1 = applicationFormFieldRepository.saveAll(applicationFormFieldEntities);
+        return applicationFormFieldEntities1;
+    }
+
+    public List<ApplicationFormFieldResponseBean> convertApplicationFormFieldEntitiesToApplicationFormFieldResponseBeans(List<ApplicationFormFieldEntity> applicationFormFieldEntities, Long applicationFormId) {
+        return applicationFormFieldEntities.stream()
+                .map(requestBean -> convertApplicationFormFieldEntityToApplicationFormFieldResponseBean(requestBean, applicationFormId))
+                .collect(Collectors.toList());
+    }
+
+    public ApplicationFormFieldResponseBean convertApplicationFormFieldEntityToApplicationFormFieldResponseBean(ApplicationFormFieldEntity applicationFormFieldEntity, Long applicationFormId) {
+        ApplicationFormFieldResponseBean applicationFormFieldResponseBean = new ApplicationFormFieldResponseBean();
+        applicationFormFieldResponseBean.setApplicationFormId(applicationFormId);
+        applicationFormFieldResponseBean.setFieldId(applicationFormFieldEntity.getFieldId());
+        applicationFormFieldResponseBean.setFieldValue(applicationFormFieldEntity.getFieldValue());
+        applicationFormFieldResponseBean.setId(applicationFormFieldEntity.getId());
+        applicationFormFieldResponseBean.setCreatedDate(applicationFormFieldEntity.getCreatedDate());
+        applicationFormFieldResponseBean.setUpdatedDate(applicationFormFieldEntity.getUpdatedDate());
+        return applicationFormFieldResponseBean;
+    }
+    public ApplicationEntity saveApplicationEntity(ApplicationEntity application){
+        ApplicationEntity applicationEntity=applicationRepository.save(application);
+        return applicationEntity;
+    }
+
+    public ApplicationGetResponseBean getApplicationByFormId( Long applicationId,Long formId, UserEntity userEntity) {
+        List<FormApplicationResponse> formApplicationResponses = new ArrayList<>();
+        List<FormEntity> formEntities = new ArrayList<>();
+        boolean isBeneficiary = isBeneficiary(userEntity);
+        ApplicationEntity applicationEntity = isBeneficiary
+                ? applicationRepository.findByIdAndUserIdAndIsDeletedFalse(applicationId,userEntity.getId())
+                .orElseThrow(() -> new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_NOT_FOUND_MSG)))
+                : applicationRepository.findById(applicationId)
+                .stream().findFirst()
+                .orElseThrow(() -> new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_NOT_FOUND_MSG)));
+
+        if (formId != null) {
+            FormEntity formEntity = formService.validateForm(formId);
+            Optional<ApplicationEntity> application = applicationRepository.findByUserIdAndCallIdAndIsDeletedFalse(userEntity.getId(),
+                    formEntity.getCall().getId());
+            applicationEntity=application.get();
+            formEntities.add(formEntity);
+            addFormApplication(formEntity, applicationEntity, formApplicationResponses);
+        }
+      else {
+            List<ApplicationFormEntity> applicationFormEntities = applicationFormRepository.findByApplicationId(applicationEntity.getId());
+            for (ApplicationFormEntity applicationFormEntity : applicationFormEntities) {
+                FormEntity form = formService.validateForm(applicationFormEntity.getForm().getId());
+                formEntities.add(form);
+                addFormApplication(form, applicationEntity, formApplicationResponses);
+            }
+        }
+
+        return createApplicationGetResponseBean(applicationEntity, formEntities, formApplicationResponses);
+    }
+
+    private boolean isBeneficiary(UserEntity userEntity) {
+        RoleStatusEnum roleStatus = RoleStatusEnum.valueOf(userEntity.getRoleEntity().getRoleType());
+        boolean isBeneficiary = RoleStatusEnum.ROLE_BENEFICIARY.equals(roleStatus);
+        return isBeneficiary;
+    }
+
+    private void addFormApplication(FormEntity formEntity, ApplicationEntity applicationEntity,
+			List<FormApplicationResponse> formApplicationResponses) {
+    	FormApplicationResponse formApplicationResponse = processForm(formEntity, applicationEntity);
+    	if(formApplicationResponse.getContent() != null && formApplicationResponse.getFormFields() != null) {
+    		formApplicationResponses.add(formApplicationResponse);
+    	}
+		
+	}
+
+	public FormApplicationResponse processForm(FormEntity formEntity, ApplicationEntity applicationEntity) {
+    	FormApplicationResponse formApplicationResponse = createFormApplicationResponse(formEntity);
+        List<ApplicationFormFieldResponseBean> applicationFormFieldResponseBeans =new ArrayList<>();
+        ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), formEntity.getId());
+        if(applicationFormEntity!=null) {
+            List<ApplicationFormFieldEntity> applicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId());
+//            formApplicationResponse = createFormApplicationResponse(formEntity);
+            applicationFormFieldResponseBeans = createApplicationFormFieldResponse(applicationFormFieldEntities, applicationFormEntity,applicationFormFieldResponseBeans);
+            formApplicationResponse.setFormFields(applicationFormFieldResponseBeans);
+        }
+        return formApplicationResponse;
+    }
+
+    private ApplicationGetResponseBean createApplicationGetResponseBean(ApplicationEntity applicationEntity, List<FormEntity> formEntities, List<FormApplicationResponse> formApplicationResponses) {
+        ApplicationGetResponseBean applicationGetResponseBean =createApplicationGetResponseBean(applicationEntity);
+        applicationGetResponseBean.setForm(formApplicationResponses);
+        return applicationGetResponseBean;
+    }
+
+    private ApplicationGetResponseBean createApplicationGetResponseBean(ApplicationEntity applicationEntity) {
+        ApplicationGetResponseBean applicationGetResponseBean = new ApplicationGetResponseBean();
+        applicationGetResponseBean.setId(applicationEntity.getId());
+        applicationGetResponseBean.setStatus(applicationEntity.getStatus());
+        applicationGetResponseBean.setComments(applicationEntity.getComments());
+        applicationGetResponseBean.setSubmissionDate(applicationEntity.getSubmissionDate());
+        applicationGetResponseBean.setCallId(applicationEntity.getCall().getId());
+        applicationGetResponseBean.setCallTitle(applicationEntity.getCall().getName());
+        return applicationGetResponseBean;
+    }
+
+    private FormApplicationResponse createFormApplicationResponse(FormEntity formEntity) {
+        FormApplicationResponse formApplicationResponse=new FormApplicationResponse();
+        formApplicationResponse.setId(formEntity.getId());
+        formApplicationResponse.setLabel(formEntity.getLabel());
+        formApplicationResponse.setCallId(formEntity.getCall().getId());
+        formApplicationResponse.setContent(Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class));
+        return formApplicationResponse;
+    }
+
+    public ApplicationResponse createApplicationByCallId(ApplicationRequest applicationRequest,Long callId,UserEntity userEntity){
+            CallEntity call=callService.validateCall(callId);
+         call = callService.validatePublishedCall(call.getId());
+        checkIfApplicationExists(call,userEntity);
+        ApplicationEntity applicationEntity=createApplicationEntity(userEntity,call);
+        applicationEntity.setComments(applicationRequest.getComments());
+        applicationEntity=saveApplicationEntity(applicationEntity);
+        ApplicationResponse applicationResponse=getApplicationResponse(applicationEntity);
+        return applicationResponse;
+    }
+    public void checkIfApplicationExists(CallEntity call,UserEntity userEntity){
+        Optional<ApplicationEntity> applicationEntity=applicationRepository.findByUserIdAndCallIdAndIsDeletedFalse(userEntity.getId(),call.getId());
+        if(applicationEntity.isPresent()){
+            throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.APPLICATION_ALREADY_EXISTS));
+        }
+    }
+    
+
+	public ApplicationEntity getApplicationByCallAndUser(CallEntity call, UserEntity userEntity) {
+		return applicationRepository.findByUserIdAndCallIdAndIsDeletedFalse(userEntity.getId(), call.getId())
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.APPLICATION_NOT_FOUND_MSG)));
+
+	}
+
+    public void updateApplicationStatus(Long applicationId, ApplicationStatusTypeEnum status) {
+        ApplicationEntity applicationEntity = validateApplication(applicationId);
+
+        if (status.equals(ApplicationStatusTypeEnum.SUBMIT)) {
+            CallEntity callEntity = applicationEntity.getCall();
+//            Long initialFormId = callEntity.getInitialForm();
+//            Long finalFormId = callEntity.getFinalForm();
+////            if (initialFormId == null || finalFormId == null) {
+////                throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_IS_INCOMPLETE_MSG));
+////            }
+//            ApplicationFormEntity initialApplicationForm = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), initialFormId);
+//            ApplicationFormEntity finalApplicationForm = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), finalFormId);
+//            if (initialApplicationForm == null || finalApplicationForm == null) {
+//                throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_IS_INCOMPLETE_MSG));
+//            }
+            List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByCallId(applicationEntity.getCall().getId());
+                Long totalSteps=flowFormDao.calculateTotalSteps(flowEdgesList);
+                Integer completedSteps=flowFormDao.getCompletedSteps(applicationEntity);
+            if (totalSteps.intValue() != completedSteps) {
+                throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_IS_INCOMPLETE_MSG));
+            }
+            applicationEntity.setStatus(ApplicationStatusTypeEnum.SUBMIT.getValue());
+            applicationEntity.setSubmissionDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
+        } else {
+            applicationEntity.setStatus(status.getValue());
+        }
+        saveApplicationEntity(applicationEntity);
+    }
+
+    public Integer calculateProgress(Long totalSteps, Long completedSteps) {
+        if (FieldValidator.isNullOrZero(totalSteps)) {
+            throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.TOTAL_STEPS_NOT_BE_ZERO));
+        }
+
+        if (completedSteps < 0 || completedSteps > totalSteps) {
+            throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.COMPLETED_STEPS_NOT_VALID));
+        }
+
+        double progress = ((double) completedSteps / totalSteps) * 100;
+        return (int) Math.round(progress);
+    }
+    public void validateFormFields(ApplicationRequestBean request, FormEntity formEntity) {
+    List<String> errors=new ArrayList<>();
+        List<ContentResponseBean> contentResponseBeans=Utils.convertJsonStringToList(formEntity.getContent(),ContentResponseBean.class);
+
+        List<ApplicationFormFieldRequestBean> requestFields = request.getFormFields();
+
+        Map<String, String> contentMap = contentResponseBeans.stream()
+                .collect(Collectors.toMap(ContentResponseBean::getId, ContentResponseBean::getLabel)); // Change getLabel() if needed
+        FieldValidator validator = FieldValidator.create();
+        for (ApplicationFormFieldRequestBean requestField : requestFields) {
+            String fieldId = requestField.getFieldId();
+
+            if (!contentMap.containsKey(fieldId)) {
+            validator.addError(MessageFormat.format(Translator.toLocale(GepafinConstant.FIELD_ID_NOT_FOUND), fieldId));
+            }
+
+        }
+        validator.validate();
+    }
+
+    public void validateRequiredFields(FormEntity formEntity, ApplicationEntity applicationEntity, String fieldId) {
+        FlowDataEntity flowDataEntity = flowDataRepository.findByFormIdAndCallId(
+                formEntity.getId(), applicationEntity.getCall().getId());
+
+        if (flowDataEntity == null) {
+            return;
+        }
+
+        ApplicationFormFieldEntity applicationFormFieldEntity = applicationFormFieldRepository
+                .findByFieldIdAndApplicationFormFormIdAndApplicationFormApplicationId(
+                        flowDataEntity.getChoosenField(), formEntity.getId(), applicationEntity.getId())
+                .orElse(null);
+
+        if (applicationFormFieldEntity == null || !fieldId.equals(applicationFormFieldEntity.getFieldId())) {
+            return;
+        }
+        List<Long> nextFormIds = flowEdgesRepository.findBySourceIdAndCallId(
+                        formEntity.getId(), applicationEntity.getCall().getId())
+                .stream()
+                .map(FlowEdgesEntity::getTargetId)
+                .collect(Collectors.toList());
+
+        Optional<Long> nextFormIdOptional = flowDataRepository.findByChoosenValueAndFormIdIn(
+                        applicationFormFieldEntity.getFieldValue(), nextFormIds)
+                .map(FlowDataEntity::getFormId);
+
+        if (nextFormIdOptional.isPresent()) {
+            Long nextFormId = nextFormIdOptional.get();
+
+            FormEntity nextForm = formService.validateForm(nextFormId);
+            ApplicationFormEntity nextApplicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(
+                    applicationEntity.getId(), nextForm.getId());
+
+            if (nextApplicationFormEntity != null) {
+                List<ApplicationFormFieldEntity> nextApplicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(nextApplicationFormEntity.getId());
+                applicationFormFieldRepository.deleteAll(nextApplicationFormFieldEntities);
+                applicationFormRepository.delete(nextApplicationFormEntity);
+            }
+        }
+    }
+
+}

src/main/java/net/gepafin/tendermanagement/dao/CallDao.java

@@ -0,0 +1,644 @@
+package net.gepafin.tendermanagement.dao;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum;
+import net.gepafin.tendermanagement.model.response.*;
+import net.gepafin.tendermanagement.service.*;
+import net.gepafin.tendermanagement.util.Utils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.CallEntity;
+import net.gepafin.tendermanagement.entities.CallTargetAudienceChecklistEntity;
+import net.gepafin.tendermanagement.entities.DocumentEntity;
+import net.gepafin.tendermanagement.entities.EvaluationCriteriaEntity;
+import net.gepafin.tendermanagement.entities.FaqEntity;
+import net.gepafin.tendermanagement.entities.LookUpDataEntity;
+import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum;
+import net.gepafin.tendermanagement.entities.RegionEntity;
+import net.gepafin.tendermanagement.entities.UserEntity;
+import net.gepafin.tendermanagement.enums.CallStatusEnum;
+import net.gepafin.tendermanagement.enums.DocumentTypeEnum;
+import net.gepafin.tendermanagement.model.request.CreateCallRequestStep1;
+import net.gepafin.tendermanagement.model.request.CreateCallRequestStep2;
+import net.gepafin.tendermanagement.model.request.DocumentReq;
+import net.gepafin.tendermanagement.model.request.EvaluationCriteriaReq;
+import net.gepafin.tendermanagement.model.request.FaqReq;
+import net.gepafin.tendermanagement.model.request.LookUpDataReq;
+import net.gepafin.tendermanagement.model.request.UpdateCallRequestStep1;
+import net.gepafin.tendermanagement.repositories.CallRepository;
+import net.gepafin.tendermanagement.repositories.CallTargetAudienceChecklistRepository;
+import net.gepafin.tendermanagement.repositories.DocumentRepository;
+import net.gepafin.tendermanagement.repositories.EvaluationCriteriaRepository;
+import net.gepafin.tendermanagement.repositories.FaqRepository;
+import net.gepafin.tendermanagement.repositories.RegionRepository;
+import net.gepafin.tendermanagement.service.impl.CallValidatorServiceImpl;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+
+import static net.gepafin.tendermanagement.enums.RoleStatusEnum.ROLE_SUPER_ADMIN;
+import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+
+@Component
+public class CallDao {
+
+	@Autowired
+	private CallRepository callRepository;
+
+	@Autowired
+	private DocumentRepository documentRepository;
+
+	@Autowired
+	private EvaluationCriteriaRepository evaluationCriteriaRepository;
+
+	@Autowired
+	private FaqRepository faqRepository;
+
+	@Autowired
+	private RegionRepository regionRepository;
+
+	@Autowired
+	private LookUpDataService lookUpDataService;
+
+	@Autowired
+	private CallTargetAudienceChecklistRepository callTargetAudienceChecklistRepository;
+
+	@Autowired
+	private UserService userService;
+
+	@Autowired
+	private FaqService faqService;
+	@Autowired
+	private FlowDao flowDao;
+	@Autowired
+	private FormDao formDao;
+
+	public CallResponse createCallStep1(CreateCallRequestStep1 createCallRequest, Long userId) {
+		UserEntity userEntity = userService.validateUser(userId);
+		createCallRequest.setRegionId(userEntity.getRoleEntity().getRegion().getId());
+		CallEntity callEntity = convertToCallEntity(createCallRequest);
+
+		updateFaq(createCallRequest.getFaq(), callEntity, userEntity,LookUpDataTypeEnum.FAQ);
+
+		convertLookUpDataEntities(createCallRequest.getAimedTo(), callEntity,
+				LookUpDataTypeEnum.AIMED_TO);
+
+		CallResponse createCallResponseBean = getCallResponseBean(callEntity);
+		createCallResponseBean.setCurrentStep(GepafinConstant.STEP_1);
+		return createCallResponseBean;
+
+	}
+
+	public CallEntity convertToCallEntity(CreateCallRequestStep1 createCallRequest) {
+		CallEntity callEntity = new CallEntity();
+//		validateCallEntity(createCallRequest);
+		RegionEntity region = regionRepository.findById(createCallRequest.getRegionId())
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.REGION_NOT_FOUND)));
+		callEntity.setRegion(region);
+		callEntity.setName(createCallRequest.getName());
+		callEntity.setDescriptionShort(createCallRequest.getDescriptionShort());
+		callEntity.setDescriptionLong(createCallRequest.getDescriptionLong());
+		List<LocalDateTime> dates = createCallRequest.getDates();
+		if(dates!=null) {
+			if(dates.size()>1) {
+				callEntity.setStartDate(dates.get(0));
+				callEntity.setEndDate(dates.get(1));
+			}
+		}
+		callEntity.setStatus(CallStatusEnum.DRAFT.getValue());
+		callEntity.setAmountMax(createCallRequest.getAmountMax());
+		callEntity.setAmount(createCallRequest.getAmount());
+		callEntity.setConfidi(false);
+		if (createCallRequest.getConfidi() != null) {
+			callEntity.setConfidi(createCallRequest.getConfidi());
+		}
+		callEntity.setDocumentationRequested(createCallRequest.getDocumentationRequested());
+		callEntity = callRepository.save(callEntity);
+		return callEntity;
+	}
+
+	public List<EvaluationCriteriaEntity> convertToEvaluationCriteriaEntities(
+			List<EvaluationCriteriaReq> criteriaReqList, CallEntity callEntity, LookUpDataTypeEnum type) {
+		if (criteriaReqList == null) {
+			return null;
+		}
+		List<EvaluationCriteriaEntity> existingCriteria = evaluationCriteriaRepository.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), type.getValue());
+
+		List<Long> incomingIds = criteriaReqList.stream().map(EvaluationCriteriaReq::getId)
+				.filter(id -> id != null && id > 0).collect(Collectors.toList());
+
+		existingCriteria.stream().filter(criteria -> !incomingIds.contains(criteria.getId())).forEach(this::softDeleteEvaluationCriteria);
+
+		List<EvaluationCriteriaEntity> evaluationCriteriaEntities = criteriaReqList.stream()
+				.map(req -> convertToEvaluationCriteriaEntity(req, callEntity, type)).collect(Collectors.toList());
+		evaluationCriteriaRepository.saveAll(evaluationCriteriaEntities);
+		return evaluationCriteriaEntities;
+	}
+
+	private void softDeleteEvaluationCriteria(EvaluationCriteriaEntity evaluationCriteriaEntity) {
+		evaluationCriteriaEntity.setIsDeleted(true);
+		evaluationCriteriaRepository.save(evaluationCriteriaEntity);
+	}
+
+	private EvaluationCriteriaEntity convertToEvaluationCriteriaEntity(EvaluationCriteriaReq criteriaReq,
+																	   CallEntity callEntity, LookUpDataTypeEnum type) {
+		EvaluationCriteriaEntity criteriaEntity = null;
+		LookUpDataEntity lookupDataEntity = lookUpDataService.getOrCreateLookUpDataEntity(criteriaReq, type);
+		if (criteriaReq.getId() != null && criteriaReq.getId() > 0) {
+			criteriaEntity = evaluationCriteriaRepository.findById(criteriaReq.getId())
+					.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+							Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_NOT_FOUND)));
+		} else {
+			criteriaEntity = new EvaluationCriteriaEntity();
+			criteriaEntity.setCall(callEntity);
+			criteriaEntity.setLookupData(lookupDataEntity);
+			criteriaEntity.setIsDeleted(false);
+		}
+		setIfUpdated(criteriaEntity::getScore, criteriaEntity::setScore, criteriaReq.getScore());
+		if (Boolean.FALSE.equals(criteriaEntity.getLookupData().getId().equals(lookupDataEntity.getId()))) {
+			criteriaEntity.setLookupData(lookupDataEntity);
+		}
+		return criteriaEntity;
+	}
+
+
+	public List<DocumentEntity> convertToDocumentEntities(List<DocumentReq> documentReqList, Long sourceId,
+														  DocumentTypeEnum documentType) {
+		if (documentReqList == null) {
+			return null;
+		}
+
+		List<DocumentEntity> existingDocuments = documentRepository
+				.findBySourceIdAndTypeAndIsDeletedFalse(sourceId, documentType.getValue());
+
+		List<Long> incomingIds = documentReqList.stream().map(DocumentReq::getId).filter(id -> id != null && id > 0)
+				.collect(Collectors.toList());
+
+		existingDocuments.stream().filter(document -> !incomingIds.contains(document.getId()))
+				.forEach(this::softDeleteDocument);
+		List<DocumentEntity> documentEntities = documentReqList.stream()
+				.map(req -> convertToDocumentEntity(req, sourceId)).collect(Collectors.toList());
+		documentRepository.saveAll(documentEntities);
+		return documentEntities;
+	}
+
+	private void softDeleteDocument(DocumentEntity documentEntity) {
+		documentEntity.setIsDeleted(true);
+		documentRepository.save(documentEntity);
+	}
+
+	private DocumentEntity convertToDocumentEntity(DocumentReq documentReq,Long sourceId) {
+		validateDocumentEntity(documentReq.getId());
+		DocumentEntity documentEntity = documentRepository.findByIdAndSourceIdAndIsDeletedFalse(documentReq.getId(),sourceId)
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.DOCUMENT_NOT_FOUND)));
+		return documentEntity;
+	}
+
+	public List<FaqEntity> updateFaq(List<FaqReq> faqReqList, CallEntity callEntity, UserEntity userEntity, LookUpDataTypeEnum type) {
+		if (faqReqList == null) {
+			return null;
+		}
+		List<FaqEntity> existingFaqEntities = faqRepository.findByCallIdAndIsDeletedFalse(callEntity.getId());
+		List<Long> incomingIds = faqReqList.stream()
+				.map(FaqReq::getId)
+				.filter(id -> id != null && id > 0)
+				.collect(Collectors.toList());
+		existingFaqEntities.stream()
+				.filter(entity -> !incomingIds.contains(entity.getId()))
+				.forEach(this::softDeleteFaq);
+		List<FaqEntity> faqEntities = faqReqList.stream()
+				.map(req -> faqService.createOrUpdateFaqEntity(req, callEntity, userEntity, type))
+				.collect(Collectors.toList());
+		return faqEntities;
+	}
+
+
+	public void validateDocumentEntity(Long documentId) {
+		if (documentId == null || documentId < 1) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.DOCUMENT_ID_NOT_FOUND));
+		}
+	}
+
+	public void validateEvaluationCriteriaEntity(String name) {
+		if (!StringUtils.hasText(name)) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.NAME_NOT_EMPTY_MSG));
+		}
+	}
+
+	public CallResponse convertToCallResponseBean(CallEntity callEntity) {
+		CallResponse createCallResponseBean = new CallResponse();
+		createCallResponseBean.setId(callEntity.getId());
+		createCallResponseBean.setName(callEntity.getName());
+		List<LocalDateTime> dates = new ArrayList<>();
+		dates.add(callEntity.getStartDate());
+		dates.add(callEntity.getEndDate());
+		createCallResponseBean.setDates(dates);
+		createCallResponseBean.setDescriptionShort(callEntity.getDescriptionShort());
+		createCallResponseBean.setDescriptionLong(callEntity.getDescriptionLong());
+		createCallResponseBean.setStatus(CallStatusEnum.valueOf(callEntity.getStatus()));
+		createCallResponseBean.setRegionId(callEntity.getRegion().getId());
+		createCallResponseBean.setAmount(callEntity.getAmount());
+		createCallResponseBean.setAmountMax(callEntity.getAmountMax());
+		createCallResponseBean.setContactInfo(callEntity.getContactInfo());
+		createCallResponseBean.setSubmissionMethod(callEntity.getSubmissionMethod());
+		createCallResponseBean.setThreshold(callEntity.getThreshold());
+		createCallResponseBean.setDocumentationRequested(callEntity.getDocumentationRequested());
+		createCallResponseBean.setPriorityArea(callEntity.getPriorityArea());
+		createCallResponseBean.setConfidi(callEntity.getConfidi());
+		createCallResponseBean.setCreatedDate(callEntity.getCreatedDate());
+		createCallResponseBean.setUpdatedDate(callEntity.getUpdatedDate());
+		return createCallResponseBean;
+	}
+
+	public EvaluationCriteriaResponseBean convertToEvaluationCriteriaResponseBean(EvaluationCriteriaEntity entity) {
+		EvaluationCriteriaResponseBean responseBean = new EvaluationCriteriaResponseBean();
+		responseBean.setId(entity.getId());
+		responseBean.setLookUpDataId(entity.getLookupData().getId());
+		responseBean.setTitle(entity.getLookupData().getTitle());
+		responseBean.setValue(entity.getLookupData().getValue());
+		responseBean.setResponse(entity.getLookupData().getResponse());
+		responseBean.setScore(entity.getScore());
+		responseBean.setCreatedDate(entity.getCreatedDate());
+		responseBean.setUpdatedDate(entity.getUpdatedDate());
+		return responseBean;
+	}
+
+	public DocumentResponseBean convertToDocumentResponseBean(DocumentEntity entity) {
+		DocumentResponseBean responseBean = new DocumentResponseBean();
+		responseBean.setId(entity.getId());
+		responseBean.setName(entity.getFileName());
+		responseBean.setType(DocumentTypeEnum.valueOf(entity.getType()));
+		responseBean.setSource(DocumentSourceTypeEnum.valueOf(entity.getSource()));
+		responseBean.setSourceId(entity.getSourceId());
+		responseBean.setFilePath(entity.getFilePath());
+		responseBean.setCreatedDate(entity.getCreatedDate());
+		responseBean.setUpdatedDate(entity.getUpdatedDate());
+		return responseBean;
+	}
+
+	public CallResponse assembleCreateCallResponseBean(CallEntity callEntity,
+			List<EvaluationCriteriaEntity> evaluationCriteriaEntities, List<DocumentEntity> documentEntities,
+			List<DocumentEntity> images) {
+
+		CallResponse callResponseBean = convertToCallResponseBean(callEntity);
+
+		List<EvaluationCriteriaResponseBean> evaluationCriteriaResponseBeans = evaluationCriteriaEntities.stream()
+				.map(this::convertToEvaluationCriteriaResponseBean).collect(Collectors.toList());
+
+		List<DocumentResponseBean> documentResponseBeans = documentEntities.stream()
+				.map(this::convertToDocumentResponseBean).collect(Collectors.toList());
+
+
+		List<DocumentResponseBean> imagesResponseBean = images.stream().map(this::convertToDocumentResponseBean)
+				.collect(Collectors.toList());
+		CallResponse createCallResponseBean = callResponseBean;
+		createCallResponseBean.setCriteria(evaluationCriteriaResponseBeans);
+		createCallResponseBean.setDocs(documentResponseBeans);
+		createCallResponseBean.setImages(imagesResponseBean);
+		return createCallResponseBean;
+	}
+
+	public List<LookUpDataResponse> convertLookUpDataEntities(List<LookUpDataReq> lookUpData, CallEntity callEntity,
+															  LookUpDataEntity.LookUpDataTypeEnum type) {
+		if(lookUpData == null) {
+			return null;
+		}
+		List<LookUpDataEntity> lookUpDataEntities = lookUpData.stream()
+				.map(req -> lookUpDataService.getOrCreateLookUpDataEntity(req, type)).collect(Collectors.toList());
+
+		return createCallTargetAudienceCheckList(callEntity, lookUpDataEntities);
+	}
+
+	private List<LookUpDataResponse> createCallTargetAudienceCheckList(CallEntity callEntity,
+																	   List<LookUpDataEntity> lookUpDataEntities) {
+		List<LookUpDataResponse> lookUpDataResponses = new ArrayList<>();
+		for (LookUpDataEntity lookUpDataEntity : lookUpDataEntities) {
+			CallTargetAudienceChecklistEntity callTargetAudienceChecklistEntity = new CallTargetAudienceChecklistEntity();
+			callTargetAudienceChecklistEntity.setIsValidated(false);
+			callTargetAudienceChecklistEntity.setLookupData(lookUpDataEntity);
+			callTargetAudienceChecklistEntity.setCall(callEntity);
+			callTargetAudienceChecklistEntity.setIsDeleted(false);
+			callTargetAudienceChecklistEntity = callTargetAudienceChecklistRepository
+					.save(callTargetAudienceChecklistEntity);
+			lookUpDataResponses.add(convertToLookUpDataResponseBean(callTargetAudienceChecklistEntity));
+		}
+		return lookUpDataResponses;
+	}
+
+	public LookUpDataResponse convertToLookUpDataResponseBean(
+			CallTargetAudienceChecklistEntity callTargetAudienceChecklistEntity) {
+		LookUpDataResponse lookUpDataResponse = new LookUpDataResponse();
+		LookUpDataEntity lookUpDataEntity = callTargetAudienceChecklistEntity.getLookupData();
+		lookUpDataResponse.setId(callTargetAudienceChecklistEntity.getId());
+		lookUpDataResponse.setLookUpDataId(lookUpDataEntity.getId());
+		lookUpDataResponse.setValue(lookUpDataEntity.getValue());
+		lookUpDataResponse.setTitle(lookUpDataEntity.getTitle());
+		lookUpDataResponse.setResponse(lookUpDataEntity.getResponse());
+		lookUpDataResponse.setCreatedDate(callTargetAudienceChecklistEntity.getCreatedDate());
+		lookUpDataResponse.setUpdatedDate(callTargetAudienceChecklistEntity.getUpdatedDate());
+		return lookUpDataResponse;
+	}
+
+	public CallEntity validateCall(Long callId) {
+		return callRepository.findById(callId).orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+				Translator.toLocale(GepafinConstant.CALL_NOT_FOUND)));
+	}
+
+	public CallResponse getCallById(Long callId) {
+		CallEntity callEntity = validateCall(callId);
+		return getCallResponseBean(callEntity);
+	}
+
+	public CallResponse createCallStep2(Long callId, CreateCallRequestStep2 createCallRequest, Long userId) {
+		CallEntity callEntity = validateCall(callId);
+		validateUpdate(callEntity);
+		setIfUpdated(callEntity::getThreshold, callEntity::setThreshold, createCallRequest.getThreshold());
+		callRepository.save(callEntity);
+		convertToEvaluationCriteriaEntities(createCallRequest.getCriteria(), callEntity, LookUpDataTypeEnum.EVALUATION_CRITERIA);
+
+		convertToDocumentEntities(createCallRequest.getDocs(), callEntity.getId(), DocumentTypeEnum.DOCUMENT);
+
+		convertToDocumentEntities(createCallRequest.getImages(), callEntity.getId(), DocumentTypeEnum.IMAGES);
+
+		updateLookUpData(callEntity, createCallRequest.getCheckList(), LookUpDataTypeEnum.CHECKLIST);
+
+//		List<FaqEntity> faqEntities = faqRepository.findByCallIdAndIsDeletedFalse(callEntity.getId());
+//		List<LookUpDataResponse> amiedTo = callTargetAudienceChecklistRepository
+//				.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.AIMED_TO.getValue()).stream()
+//				.map(this::convertToLookUpDataResponseBean).toList();
+//		createCallResponseBean = assembleCreateCallResponseBean(callEntity, evaluationCriteriaEntities,
+//				documentEntities, faqEntities, imageEntities);
+//		createCallResponseBean.setAimedTo(amiedTo);
+//		createCallResponseBean.setCheckList(checkList);
+		CallResponse createCallResponseBean = getCallResponseBean(callEntity);
+		createCallResponseBean.setCurrentStep(GepafinConstant.STEP_2);
+		return createCallResponseBean;
+	}
+
+	public void validateUpdate(CallEntity callEntity) {
+		if(callEntity.getStatus().equals(CallStatusEnum.PUBLISH.getValue())) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.PUBLISHED_CALL_NOT_UPDATE));
+		}
+	}
+
+	public void isValidDateRange(UpdateCallRequestStep1 updateCallRequest, CallEntity callEntity) {
+		List<LocalDateTime> dates = updateCallRequest.getDates();
+
+		LocalDate startDate = (dates != null && dates.size() > 0 && dates.get(0) != null)
+		                     ? dates.get(0).toLocalDate()
+		                     : null;
+
+		LocalDate endDate = (dates != null && dates.size() > 1 && dates.get(1) != null)
+		                   ? dates.get(1).toLocalDate()
+		                   : null;
+
+		Boolean isValid = true;
+		if (startDate != null && endDate != null && startDate.isAfter(endDate)) {
+			isValid = false;
+		} else if (startDate != null && endDate == null && callEntity.getEndDate() != null
+				&& startDate.isAfter(callEntity.getEndDate().toLocalDate())) {
+			isValid = false;
+		} else if (startDate == null && endDate != null && callEntity.getStartDate() != null
+				&& callEntity.getStartDate().toLocalDate().isAfter(endDate)) {
+			isValid = false;
+		}
+
+		if (Boolean.FALSE.equals(isValid)) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.INVALID_DATE_MSG));
+		}
+	}
+
+	public CallResponse updateCallStep1(Long callId, UpdateCallRequestStep1 updateCallRequest, Long userId) {
+		CallEntity callEntity = validateCall(callId);
+		if(Boolean.TRUE.equals(callEntity.getStatus().equals(CallStatusEnum.PUBLISH.getValue()))) {
+			try {
+				Utils.retainOnlySpecificFields(updateCallRequest, Collections.singletonList("faq"));
+			} catch (IllegalAccessException e) {
+				throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.FAILED_RETAIN_FIELD));
+			}
+        }
+			UserEntity userEntity = userService.validateUser(userId);
+		isValidDateRange(updateCallRequest, callEntity);
+		setIfUpdated(callEntity::getName, callEntity::setName, updateCallRequest.getName());
+		setIfUpdated(callEntity::getDescriptionShort, callEntity::setDescriptionShort,
+				updateCallRequest.getDescriptionShort());
+		setIfUpdated(callEntity::getDescriptionLong, callEntity::setDescriptionLong,
+				updateCallRequest.getDescriptionLong());
+		List<LocalDateTime> dates=updateCallRequest.getDates();
+
+		if (dates != null && dates.size()>1) {
+		    if (dates.size() > 0) {
+		        setIfUpdated(callEntity::getStartDate, callEntity::setStartDate, dates.get(0));
+		    }
+		    if (dates.size() > 1) {
+		        setIfUpdated(callEntity::getEndDate, callEntity::setEndDate, dates.get(1));
+		    }
+		}
+//		setIfUpdated(callEntity::getStartDate, callEntity::setStartDate, updateCallRequest.getStartDate());
+//		setIfUpdated(callEntity::getEndDate, callEntity::setEndDate, updateCallRequest.getEndDate());
+		setIfUpdated(callEntity::getAmount, callEntity::setAmount, updateCallRequest.getAmount());
+		setIfUpdated(callEntity::getAmountMax, callEntity::setAmountMax, updateCallRequest.getAmountMax());
+		setIfUpdated(callEntity::getDocumentationRequested, callEntity::setDocumentationRequested,
+				updateCallRequest.getDocumentationRequested());
+		setIfUpdated(callEntity::getConfidi, callEntity::setConfidi, updateCallRequest.getConfidi());
+		updateLookUpData(callEntity, updateCallRequest.getAimedTo(), LookUpDataTypeEnum.AIMED_TO);
+		updateFaq(updateCallRequest.getFaq(), callEntity, userEntity, LookUpDataTypeEnum.FAQ);
+		CallResponse createCallResponseBean = getCallResponseBean(callEntity);
+		createCallResponseBean.setCurrentStep(GepafinConstant.STEP_1);
+		return createCallResponseBean;
+	}
+
+	private void softDeleteFaq(FaqEntity faqEntity) {
+		faqEntity.setIsDeleted(true);
+		faqRepository.save(faqEntity);
+	}
+
+	private void updateLookUpData(CallEntity callEntity, List<LookUpDataReq> lookupDataReqList, LookUpDataTypeEnum type) {
+		if (lookupDataReqList == null) {
+			return;
+		}
+		List<CallTargetAudienceChecklistEntity> existingChecklist = callTargetAudienceChecklistRepository
+				.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), type.getValue());
+		List<Long> incomingIds = lookupDataReqList.stream().map(LookUpDataReq::getLookUpDataId)
+				.filter(id -> id != null && id > 0).collect(Collectors.toList());
+		existingChecklist.stream().filter(checklist -> !incomingIds.contains(checklist.getLookupData().getId()))
+				.forEach(this::softDeleteCallTargetAudienceChecklist);
+		lookupDataReqList
+				.forEach(lookUpDataReq -> createOrUpdateCallTargetAudienceChecklist(lookUpDataReq, callEntity, type));
+	}
+
+	private void createOrUpdateCallTargetAudienceChecklist(LookUpDataReq lookUpDataReq, CallEntity callEntity,
+														   LookUpDataTypeEnum type) {
+		CallTargetAudienceChecklistEntity checklistEntity = null;
+		LookUpDataEntity lookupDataEntity = lookUpDataService.getOrCreateLookUpDataEntity(lookUpDataReq, type);
+		if (lookUpDataReq.getId() != null && lookUpDataReq.getId() > 0) {
+			checklistEntity = callTargetAudienceChecklistRepository.findById(lookUpDataReq.getId())
+					.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+							Translator.toLocale(GepafinConstant.CALL_NOT_FOUND)));
+
+			if (Boolean.FALSE.equals(checklistEntity.getLookupData().getId().equals(lookupDataEntity.getId()))) {
+				checklistEntity.setLookupData(lookupDataEntity);
+			}
+		} else {
+			checklistEntity = new CallTargetAudienceChecklistEntity();
+			checklistEntity.setCall(callEntity);
+			checklistEntity.setLookupData(lookupDataEntity);
+			checklistEntity.setIsValidated(false);
+			checklistEntity.setIsDeleted(false);
+		}
+
+		callTargetAudienceChecklistRepository.save(checklistEntity);
+	}
+
+	private void softDeleteCallTargetAudienceChecklist(
+			CallTargetAudienceChecklistEntity callTargetAudienceChecklistEntity) {
+		callTargetAudienceChecklistEntity.setIsDeleted(true);
+		callTargetAudienceChecklistRepository.save(callTargetAudienceChecklistEntity);
+	}
+
+	public CallDetailsResponseBean convertToCallDetailsResponseBean(CallEntity callEntity) {
+		CallDetailsResponseBean callDetailsResponseBean = new CallDetailsResponseBean();
+		callDetailsResponseBean.setId(callEntity.getId());
+		callDetailsResponseBean.setName(callEntity.getName());
+		List<LocalDateTime> dates = new ArrayList<>();
+		dates.add(callEntity.getStartDate());
+		dates.add(callEntity.getEndDate());
+		callDetailsResponseBean.setDates(dates);
+		callDetailsResponseBean.setDescriptionShort(callEntity.getDescriptionShort());
+		callDetailsResponseBean.setDescriptionLong(callEntity.getDescriptionLong());
+		callDetailsResponseBean.setStatus(CallStatusEnum.valueOf(callEntity.getStatus()));
+		callDetailsResponseBean.setRegionId(callEntity.getRegion().getId());
+		callDetailsResponseBean.setAmount(callEntity.getAmount());
+		callDetailsResponseBean.setAmountMax(callEntity.getAmountMax());
+		callDetailsResponseBean.setContactInfo(callEntity.getContactInfo());
+		callDetailsResponseBean.setSubmissionMethod(callEntity.getSubmissionMethod());
+		callDetailsResponseBean.setThreshold(callEntity.getThreshold());
+		callDetailsResponseBean.setDocumentationRequested(callEntity.getDocumentationRequested());
+		callDetailsResponseBean.setPriorityArea(callEntity.getPriorityArea());
+		callDetailsResponseBean.setCreatedDate(callEntity.getCreatedDate());
+		callDetailsResponseBean.setUpdatedDate(callEntity.getUpdatedDate());
+		return callDetailsResponseBean;
+	}
+
+	private CallResponse getCallResponseBean(CallEntity callEntity) {
+		List<DocumentEntity> documentEntities = documentRepository.findBySourceIdAndTypeAndIsDeletedFalse(callEntity.getId(),
+				DocumentTypeEnum.DOCUMENT.getValue());
+		List<DocumentEntity> imageEntities = documentRepository.findBySourceIdAndTypeAndIsDeletedFalse(callEntity.getId(),
+				DocumentTypeEnum.IMAGES.getValue());
+		List<LookUpDataResponse> amiedTo = callTargetAudienceChecklistRepository
+				.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.AIMED_TO.getValue()).stream()
+				.map(this::convertToLookUpDataResponseBean).toList();
+
+		List<LookUpDataResponse> checkList = callTargetAudienceChecklistRepository
+				.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.CHECKLIST.getValue()).stream()
+				.map(this::convertToLookUpDataResponseBean).toList();
+		List<EvaluationCriteriaEntity> evaluationCriteriaEntities = evaluationCriteriaRepository
+				.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.EVALUATION_CRITERIA.getValue());
+
+		CallResponse createCallResponseBean = assembleCreateCallResponseBean(callEntity, evaluationCriteriaEntities,
+				documentEntities, imageEntities);
+		createCallResponseBean.setFaq(faqService.getFaqByCallId(callEntity.getId()));
+		createCallResponseBean.setAimedTo(amiedTo);
+		createCallResponseBean.setCheckList(checkList);
+		return createCallResponseBean;
+	}
+
+	public List<CallDetailsResponseBean> getAllCalls(UserEntity user) {
+	    String type=user.getRoleEntity().getRoleType();
+		List<String> callStatusList =CallStatusEnum.getStatusValues();
+		if (Boolean.FALSE.equals(ROLE_SUPER_ADMIN.getValue().equals(type))) {
+			callStatusList = List.of(CallStatusEnum.PUBLISH.getValue());
+		}
+		List<CallEntity> calls = callRepository.findByStatusIn(callStatusList);
+		return calls.stream()
+				.map(this::convertToCallDetailsResponseBean)
+				.collect(Collectors.toList());
+	}
+
+	public CallResponse validateCallData(CallEntity callEntity) {
+		validateUpdate(callEntity);
+		CallResponse callResponseBean = getCallResponseBean(callEntity);
+		FlowResponseBean flowResponseBean = flowDao.getFlowByCallId(callEntity.getId());
+		List<FormResponseBean> formResponseBean = formDao.getFormsByCallId(callEntity.getId());
+		CallValidatorServiceImpl.validateResponse(callResponseBean,flowResponseBean,formResponseBean);
+		callEntity.setStatus(CallStatusEnum.READY_TO_PUBLISH.getValue());
+		callRepository.save(callEntity);
+		callResponseBean.setCurrentStep(GepafinConstant.VALIDATE_REQUEST);
+		callResponseBean.setStatus(CallStatusEnum.valueOf(callEntity.getStatus()));
+		return callResponseBean;
+	}
+    public CallEntity getCallEntityById(Long id){
+        CallEntity callEntity=callRepository.findByIdAndStatusNotIn(id,List.of(CallStatusEnum.PUBLISH.getValue()));
+        if(callEntity==null){
+            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.CALL_NOT_FOUND));
+        }
+        return callEntity;
+    }
+
+	public CallResponse updateCallStatus(Long callId, CallStatusEnum statusReq) {
+		CallEntity callEntity = validateCall(callId);
+		CallStatusEnum currentStatus = CallStatusEnum.valueOf(callEntity.getStatus());
+		validateStatusChange(currentStatus, statusReq);
+		callEntity.setStatus(statusReq.getValue());
+		callEntity = callRepository.save(callEntity);
+		return convertToCallResponseBean(callEntity);
+	}
+
+	private void validateStatusChange(CallStatusEnum currentStatus, CallStatusEnum newStatus) {
+		if (currentStatus == newStatus) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.STATUS_SAME_ERROR));
+		}
+
+		switch (currentStatus) {
+		case DRAFT:
+			if (newStatus == CallStatusEnum.READY_TO_PUBLISH || newStatus == CallStatusEnum.PUBLISH) {
+				throw new CustomValidationException(Status.VALIDATION_ERROR,
+						Translator.toLocale(GepafinConstant.INVALID_STATUS_CHANGE_FROM_DRAFT));
+			}
+			break;
+		case PUBLISH:
+			if (newStatus == CallStatusEnum.READY_TO_PUBLISH || newStatus == CallStatusEnum.DRAFT) {
+				throw new CustomValidationException(Status.VALIDATION_ERROR,
+						Translator.toLocale(GepafinConstant.INVALID_STATUS_CHANGE_FROM_PUBLISH));
+			}
+			break;
+
+		case EXPIRED:
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.STATUS_CANNOT_BE_CHANGED));
+		case READY_TO_PUBLISH:
+			break;
+		default:
+			break;
+
+		}
+	}
+	public CallEntity validatePublishedCall(Long callId) {
+		CallEntity callEntity= callRepository
+				.findByIdAndStatus(callId, CallStatusEnum.PUBLISH.getValue());
+		if(callEntity==null){
+			throw new ResourceNotFoundException(
+						Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.CALL_NOT_PUBLISHED));
+		}
+		return callEntity;
+	}
+
+}

src/main/java/net/gepafin/tendermanagement/dao/DocumentDao.java

@@ -0,0 +1,137 @@
+package net.gepafin.tendermanagement.dao;
+
+import java.io.IOException;
+import java.util.stream.Collectors;
+
+import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum;
+import org.apache.commons.io.FilenameUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.CallEntity;
+import net.gepafin.tendermanagement.entities.DocumentEntity;
+import net.gepafin.tendermanagement.enums.DocumentTypeEnum;
+import net.gepafin.tendermanagement.model.response.DocumentResponseBean;
+import net.gepafin.tendermanagement.repositories.DocumentRepository;
+import net.gepafin.tendermanagement.service.AmazonS3Service;
+import net.gepafin.tendermanagement.service.CallService;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+public class DocumentDao {
+
+	@Autowired
+	private AmazonS3Service amazonS3Service;
+
+	@Autowired
+	private DocumentRepository documentRepository;
+
+	@Autowired
+	private CallDao callDao;
+
+	@Autowired
+	private CallService callService;
+
+	public List<DocumentResponseBean> uploadFiles(List<MultipartFile> files, Long sourceId, DocumentSourceTypeEnum sourceType, DocumentTypeEnum fileType) {
+		List<DocumentEntity> documentEntities = new ArrayList<>();
+		Long source = resolveSourceId(sourceId, sourceType);
+		for (MultipartFile file : files) {
+			try {
+				uploadFileOnAmazonS3 result = uploadFileOnAmazonS3(file);
+				if (result != null) {
+					DocumentEntity documentEntity = new DocumentEntity();
+					documentEntity.setFileName(result.fileName());
+					documentEntity.setSource(sourceType.getValue());
+					documentEntity.setSourceId(source);
+					documentEntity.setType(fileType.getValue());
+					documentEntity.setFilePath(result.filepath());
+					documentEntity.setIsDeleted(false);
+					documentEntities.add(documentEntity);
+				}
+			} catch (IOException e) {
+			}
+		}
+		documentRepository.saveAll(documentEntities);
+		return documentEntities.stream().map(callDao::convertToDocumentResponseBean).collect(Collectors.toList());
+	}
+	private Long resolveSourceId(Long sourceId, DocumentSourceTypeEnum sourceType) {
+		if (sourceType == DocumentSourceTypeEnum.CALL) {
+			CallEntity callEntity = callService.validateCall(sourceId);
+			return callEntity.getId();
+		}
+//		else if (sourceType == SourceTypeEnum.APPLICATION) {
+//			ApplicationEntity applicationEntity = applicationService.validateApplication(sourceId);
+//			return applicationEntity.getId(); // Assuming ApplicationEntity has getId()
+//		}
+//
+		return sourceId;
+	}
+
+	private uploadFileOnAmazonS3 uploadFileOnAmazonS3(MultipartFile file) throws IOException {
+		String extension = FilenameUtils.getExtension(file.getOriginalFilename());
+		String fileName = StringUtils.cleanPath(file.getOriginalFilename());
+		String firstNameContain = fileName.substring(0, fileName.lastIndexOf('.'));
+		fileName = (firstNameContain + "." + extension);
+		String filepath = amazonS3Service.upload(fileName, file);
+		uploadFileOnAmazonS3 result = new uploadFileOnAmazonS3(fileName, filepath);
+		return result;
+	}
+
+	private record uploadFileOnAmazonS3(String fileName, String filepath) {
+	}
+
+	public void deleteFile(Long documentId) {
+		DocumentEntity documentEntity = validateDocument(documentId);
+//        String fileName= Utils.extractFileName(documentEntity.getFilePath());
+//        deleteFileOnAmazonS3(fileName);
+		documentEntity.setIsDeleted(true);
+		documentRepository.save(documentEntity);
+	}
+
+	private DocumentEntity deleteFileOnAmazonS3(String fileName) {
+		try {
+			amazonS3Service.delete(fileName);
+		} catch (Exception e) {
+		}
+		return null;
+	}
+
+	public DocumentEntity validateDocument(Long id) {
+		return documentRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+				Translator.toLocale(GepafinConstant.DOCUMENT_NOT_FOUND)));
+	}
+
+	public DocumentResponseBean updateDocument(Long documentId, MultipartFile file, DocumentTypeEnum documentTypeEnum) {
+		DocumentEntity documentEntity = validateDocument(documentId);
+		String fileName = Utils.extractFileName(documentEntity.getFilePath());
+		deleteFileOnAmazonS3(fileName);
+		uploadFileOnAmazonS3 result = null;
+		try {
+			result = uploadFileOnAmazonS3(file);
+		} catch (IOException e) {
+		}
+		if (result != null) {
+			documentEntity.setFilePath(result.filepath);
+			documentEntity.setFileName(result.fileName);
+			documentEntity.setType(documentTypeEnum.getValue());
+			documentEntity.setSource(documentEntity.getSource());
+			documentEntity.setSourceId(documentEntity.getSourceId());
+			documentRepository.save(documentEntity);
+		}
+		return callDao.convertToDocumentResponseBean(documentEntity);
+	}
+
+	public DocumentResponseBean getDocument(Long documentId) {
+		DocumentEntity documentEntity = validateDocument(documentId);
+		return callDao.convertToDocumentResponseBean(documentEntity);
+	}
+}

src/main/java/net/gepafin/tendermanagement/dao/EvaluationCriteriaDao.java

@@ -0,0 +1,87 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.CallEntity;
+import net.gepafin.tendermanagement.entities.EvaluationCriteriaEntity;
+import net.gepafin.tendermanagement.entities.LookUpDataEntity;
+import net.gepafin.tendermanagement.model.request.EvaluationCriteriaRequest;
+import net.gepafin.tendermanagement.model.response.EvaluationCriteriaResponseBean;
+import net.gepafin.tendermanagement.repositories.EvaluationCriteriaRepository;
+import net.gepafin.tendermanagement.service.CallService;
+import net.gepafin.tendermanagement.service.LookUpDataService;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.stereotype.Component;
+
+@Component
+public class EvaluationCriteriaDao {
+
+	@Autowired
+	private EvaluationCriteriaRepository evaluationCriteriaRepository;
+
+	@Autowired
+	private CallService callService;
+
+	@Autowired
+	private LookUpDataService lookUpDataService;
+
+	public EvaluationCriteriaResponseBean createEvaluationCriteria(
+			EvaluationCriteriaRequest evaluationCriteriaRequest) {
+		EvaluationCriteriaEntity entity = convertEvaluationCriteriaRequestToEvaluationCriteriaEntity(
+				evaluationCriteriaRequest);
+		return convertEvaluationCriteriaEntityEvaluationCriteriaToResponseBean(entity);
+	}
+
+	private EvaluationCriteriaEntity convertEvaluationCriteriaRequestToEvaluationCriteriaEntity(
+			EvaluationCriteriaRequest evaluationCriteriaRequest) {
+		EvaluationCriteriaEntity entity = new EvaluationCriteriaEntity();
+		CallEntity callEntity = callService.validateCall(evaluationCriteriaRequest.getCallId());
+		LookUpDataEntity looDataEntity = lookUpDataService
+				.validateLookUpData(evaluationCriteriaRequest.getLookUpDataId());
+		entity.setCall(callEntity);
+		entity.setLookupData(looDataEntity);
+		entity.setScore(evaluationCriteriaRequest.getScore());
+		entity = evaluationCriteriaRepository.save(entity);
+		return entity;
+	}
+
+	public EvaluationCriteriaResponseBean getEvaluationCriteriaById(Long id) {
+		return evaluationCriteriaRepository.findById(id)
+				.map(this::convertEvaluationCriteriaEntityEvaluationCriteriaToResponseBean)
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_NOT_FOUND)));
+	}
+
+	public EvaluationCriteriaResponseBean updateEvaluationCriteria(Long id, EvaluationCriteriaRequest request) {
+		EvaluationCriteriaEntity entity = evaluationCriteriaRepository.findById(id)
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_NOT_FOUND)));
+		entity = convertEvaluationCriteriaRequestToEvaluationCriteriaEntity(request);
+		return convertEvaluationCriteriaEntityEvaluationCriteriaToResponseBean(entity);
+	}
+
+	public void deleteEvaluationCriteria(Long id) {
+		try {
+			evaluationCriteriaRepository.deleteById(id);
+		} catch (EmptyResultDataAccessException e) {
+			throw new ResourceNotFoundException(Status.NOT_FOUND,
+					Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_NOT_FOUND));
+		}
+	}
+
+	private EvaluationCriteriaResponseBean convertEvaluationCriteriaEntityEvaluationCriteriaToResponseBean(
+			EvaluationCriteriaEntity entity) {
+		EvaluationCriteriaResponseBean response = new EvaluationCriteriaResponseBean();
+		response.setId(entity.getId());
+		response.setScore(entity.getScore());
+		response.setCreatedDate(entity.getCreatedDate());
+		response.setUpdatedDate(entity.getUpdatedDate());
+		response.setLookUpDataId(entity.getLookupData().getId());
+		response.setTitle(entity.getLookupData().getTitle());
+		response.setValue(entity.getLookupData().getValue());
+		return response;
+	}
+}

src/main/java/net/gepafin/tendermanagement/dao/FaqDao.java

@@ -0,0 +1,123 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.CallEntity;
+import net.gepafin.tendermanagement.entities.FaqEntity;
+import net.gepafin.tendermanagement.entities.LookUpDataEntity;
+import net.gepafin.tendermanagement.entities.UserEntity;
+import net.gepafin.tendermanagement.enums.RoleStatusEnum;
+import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum;
+import net.gepafin.tendermanagement.model.request.FaqReq;
+import net.gepafin.tendermanagement.model.response.FaqResponseBean;
+import net.gepafin.tendermanagement.repositories.FaqRepository;
+import net.gepafin.tendermanagement.service.CallService;
+import net.gepafin.tendermanagement.service.LookUpDataService;
+import net.gepafin.tendermanagement.util.DateTimeUtil;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Component
+public class FaqDao {
+
+	@Autowired
+	private FaqRepository faqRepository;
+
+	@Autowired
+	private CallService callService;
+	
+	@Autowired
+	private LookUpDataService lookUpDataService;
+
+	public FaqResponseBean createFaq(FaqReq faqRequest, UserEntity userEntity, Long callId) {
+		FaqEntity entity = new FaqEntity();
+		CallEntity callEntity = callService.validateCall(callId);
+		entity = createOrUpdateFaqEntity(faqRequest, callEntity, userEntity,
+				LookUpDataEntity.LookUpDataTypeEnum.FAQ);
+		faqRepository.save(entity);
+		return convertToFaqResponseBean(entity);
+	}
+
+	public FaqResponseBean getFaqById(Long id) {
+		return convertToFaqResponseBean(validateFaq(id));
+	}
+
+	public FaqResponseBean updateFaq(Long id, FaqReq faqRequest, UserEntity userEntity) {
+		FaqEntity entity = validateFaq(id);
+		faqRequest.setId(entity.getId());
+		createOrUpdateFaqEntity(faqRequest, entity.getCall(), userEntity, LookUpDataEntity.LookUpDataTypeEnum.FAQ);
+		return convertToFaqResponseBean(entity);
+	}
+
+	public void deleteFaq(Long id) {
+		FaqEntity faqEntity = validateFaq(id);
+		faqEntity.setIsDeleted(Boolean.TRUE);
+		faqRepository.save(faqEntity);
+	}
+	
+	public FaqEntity validateFaq(Long id) {
+		return faqRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+				Translator.toLocale(GepafinConstant.FAQ_NOT_FOUND)));
+	}
+	
+	public List<FaqResponseBean> getFaqByCallId(Long callId) {
+		callService.validateCall(callId);
+		return faqRepository.findByCallIdAndIsDeletedFalse(callId).stream().map(this::convertToFaqResponseBean)
+				.toList();
+	}
+
+	
+	public FaqEntity createOrUpdateFaqEntity(FaqReq faqReq, CallEntity callEntity, UserEntity userEntity,
+			LookUpDataTypeEnum type) {
+		FaqEntity faqEntity = null;
+		if (isExistingFaq(faqReq)) {
+			faqEntity = faqRepository.findByIdAndCallIdAndIsDeletedFalse(faqReq.getId(), callEntity.getId())
+					.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+							Translator.toLocale(GepafinConstant.FAQ_NOT_FOUND)));
+		} else {
+			if (Boolean.FALSE.equals(userEntity.getRoleEntity().getRoleType().equals(RoleStatusEnum.ROLE_BENEFICIARY.getValue()))) {
+				lookUpDataService.getOrCreateLookUpDataEntity(faqReq, type);
+			}
+			faqEntity = new FaqEntity();
+			faqEntity.setCall(callEntity);
+			faqEntity.setUser(userEntity);
+			faqEntity.setIsVisible(false);
+			faqEntity.setIsDeleted(false);
+		}
+		if (faqReq.getResponse() != null && (faqEntity.getResponse() == null
+				|| Boolean.FALSE.equals(faqReq.getResponse().equals(faqEntity.getResponse())))) {
+			faqEntity.setResponseDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
+		}
+		setIfUpdated(faqEntity::getTitle, faqEntity::setTitle, faqReq.getTitle());
+		setIfUpdated(faqEntity::getValue, faqEntity::setValue, faqReq.getValue());
+		setIfUpdated(faqEntity::getResponse, faqEntity::setResponse, faqReq.getResponse());
+		setIfUpdated(faqEntity::getIsVisible, faqEntity::setIsVisible, faqReq.getIsVisible());
+		return faqRepository.save(faqEntity);
+	}
+	
+	private boolean isExistingFaq(FaqReq faqReq) {
+		return faqReq.getId() != null && faqReq.getId() > 0;
+	}
+
+	public FaqResponseBean convertToFaqResponseBean(FaqEntity entity) {
+		FaqResponseBean responseBean = new FaqResponseBean();
+		responseBean.setId(entity.getId());
+		responseBean.setUserId(entity.getUser().getId());
+		responseBean.setTitle(entity.getTitle());
+		responseBean.setValue(entity.getValue());
+		responseBean.setResponse(entity.getResponse());
+		responseBean.setResponseDate(entity.getResponseDate());
+		responseBean.setIsVisible(entity.getIsVisible());
+		responseBean.setCreatedDate(entity.getCreatedDate());
+		responseBean.setUpdatedDate(entity.getUpdatedDate());
+		return responseBean;
+	}
+	
+}

src/main/java/net/gepafin/tendermanagement/dao/FlowDao.java

@@ -0,0 +1,203 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.CallEntity;
+import net.gepafin.tendermanagement.entities.FlowDataEntity;
+import net.gepafin.tendermanagement.entities.FlowDataEntity;
+import net.gepafin.tendermanagement.entities.FlowEdgesEntity;
+import net.gepafin.tendermanagement.enums.CallStatusEnum;
+import net.gepafin.tendermanagement.model.request.FlowDataRequestBean;
+import net.gepafin.tendermanagement.model.request.FlowEdgesRequestBean;
+import net.gepafin.tendermanagement.model.request.FlowRequestBean;
+import net.gepafin.tendermanagement.model.response.EvaluationCriteriaResponseBean;
+import net.gepafin.tendermanagement.model.response.FlowDataResponseBean;
+import net.gepafin.tendermanagement.model.response.FlowEdgesResponseBean;
+import net.gepafin.tendermanagement.model.response.FlowResponseBean;
+import net.gepafin.tendermanagement.repositories.CallRepository;
+import net.gepafin.tendermanagement.repositories.FlowDataRepository;
+import net.gepafin.tendermanagement.repositories.FlowDataRepository;
+import net.gepafin.tendermanagement.repositories.FlowEdgesRepository;
+import net.gepafin.tendermanagement.repositories.FlowEdgesRepository;
+import net.gepafin.tendermanagement.service.CallService;
+import net.gepafin.tendermanagement.service.FormService;
+import net.gepafin.tendermanagement.util.DateTimeUtil;
+import net.gepafin.tendermanagement.util.FieldValidator;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+public class FlowDao {
+
+    @Autowired
+    private FlowDataRepository flowDataRepository;
+
+    @Autowired
+    private FlowEdgesRepository flowEdgesRepository;
+
+    @Autowired
+    private CallRepository callRepository;
+
+    @Autowired
+    private CallService callService;
+
+    @Autowired
+    private FormService formService;
+
+    @Autowired
+    private CallDao callDao;
+
+    public FlowResponseBean createOrUpdateFlow(FlowRequestBean flowRequestBean, Long callId) {
+        validateFlowRequestBean(flowRequestBean);
+        CallEntity call = callService.validateCall(callId);
+        checkIfFlowExits(call);
+        call= setInitialAndFinalFormInCall(flowRequestBean, call);
+        validateFlowRequest(flowRequestBean);
+        List<FlowDataEntity> flowDataEntities = createFlowData(flowRequestBean,call);
+        List<FlowEdgesEntity> flowEdgesEntities = createFlowEdges(flowRequestBean,call);
+        FlowResponseBean flowResponseBean = getFlowByCallId(call.getId());
+        return flowResponseBean;
+    }
+
+    public void validateFlowRequestBean(FlowRequestBean flowRequestBean){
+        if (FieldValidator.isNullOrZero(flowRequestBean.getInitialForm()) || FieldValidator.isNullOrZero(flowRequestBean.getFinalForm())) {
+            throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.INITAL_AND_FINAL_FORM_CANNOT_NULL));
+        }
+
+        if (flowRequestBean.getFlowEdges() == null || flowRequestBean.getFlowEdges().isEmpty()) {
+            throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.FLOW_REQUEST_NOT_PROPER));
+        }
+    }
+
+    public void checkIfFlowExits(CallEntity call) {
+        callDao.validateUpdate(call);
+        List<FlowDataEntity> flowDataEntities = flowDataRepository.findByCallId(call.getId());
+        List<FlowEdgesEntity> flowEdgesEntities = flowEdgesRepository.findByCallId(call.getId());
+        if (Boolean.FALSE.equals(flowDataEntities.isEmpty())  || Boolean.FALSE.equals(flowEdgesEntities.isEmpty())) {
+            call.setInitialForm(null);
+            call.setFinalForm(null);
+            call=callRepository.save(call);
+            flowDataRepository.deleteAll(flowDataEntities);
+            flowEdgesRepository.deleteAll(flowEdgesEntities);
+        }
+    }
+
+    public void validateFlowRequest(FlowRequestBean flowRequestBean) {
+        formService.validateForm(flowRequestBean.getInitialForm());
+        formService.validateForm(flowRequestBean.getFinalForm());
+        if(flowRequestBean.getFlowData()!=null && !flowRequestBean.getFlowData().isEmpty()) {
+            flowRequestBean.getFlowData().forEach(flowData -> formService.validateForm(flowData.getFormId()));
+        }
+    }
+
+    private List<FlowEdgesResponseBean> createFlowEdgesResponseBean(List<FlowEdgesEntity> flowEdgesEntities) {
+        List<FlowEdgesResponseBean> flowEdgesResponseBeans = flowEdgesEntities.stream()
+                .map(this::convertFlowEdgesEntityToFlowEdgesResponseBean).collect(Collectors.toList());
+        return flowEdgesResponseBeans;
+    }
+
+    private List<FlowDataResponseBean> createFlowDataResponseBean(List<FlowDataEntity> flowDataEntities) {
+        List<FlowDataResponseBean> flowDataResponseBeans = flowDataEntities.stream()
+                .map(this::convertFlowDataEntityToFlowDataResponseBean).collect(Collectors.toList());
+        return flowDataResponseBeans;
+    }
+
+    public FlowResponseBean setInitialAndFinalFormInFlowResponseBean(FlowResponseBean flowResponseBean, CallEntity call) {
+        flowResponseBean.setInitialForm(call.getInitialForm());
+        flowResponseBean.setFinalForm(call.getFinalForm());
+        return flowResponseBean;
+    }
+
+    private CallEntity setInitialAndFinalFormInCall(FlowRequestBean flowRequestBean, CallEntity call) {
+        call.setInitialForm(flowRequestBean.getInitialForm());
+        call.setFinalForm(flowRequestBean.getFinalForm());
+        call.setUpdatedDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
+        call = callRepository.save(call);
+        return call;
+    }
+
+    public List<FlowDataEntity> createFlowData(FlowRequestBean flowRequestBean, CallEntity call) {
+        if (flowRequestBean.getFlowData() != null || !flowRequestBean.getFlowEdges().isEmpty()) {
+            List<FlowDataEntity> flowDataEntities = flowRequestBean.getFlowData().stream()
+                    .map(flowDataRequestBean -> createFlowDataEntity(flowDataRequestBean, call))
+                    .collect(Collectors.toList());
+            return flowDataRepository.saveAll(flowDataEntities);
+        }
+        return null;
+    }
+
+    public FlowDataEntity createFlowDataEntity(FlowDataRequestBean flowDataRequestBean,CallEntity call) {
+        FlowDataEntity flowDataEntity = new FlowDataEntity();
+        flowDataEntity.setFormId(flowDataRequestBean.getFormId());
+        if(Boolean.FALSE.equals(flowDataRequestBean.getChosenField().isEmpty()) || flowDataRequestBean.getChosenField()!=null){
+        flowDataEntity.setChoosenField(flowDataRequestBean.getChosenField());
+        }
+        if(Boolean.FALSE.equals(flowDataRequestBean.getChosenValue().isEmpty()) || flowDataRequestBean.getChosenValue()!=null) {
+            flowDataEntity.setChoosenValue(flowDataRequestBean.getChosenValue());
+        }
+            flowDataEntity.setCallId(call.getId());
+        return flowDataEntity;
+    }
+
+    public List<FlowEdgesEntity> createFlowEdges(FlowRequestBean flowRequestBean, CallEntity call) {
+        List<FlowEdgesEntity> flowEdgesEntities = flowRequestBean.getFlowEdges().stream()
+                .map(flowEdgesRequestBean -> createFlowEdgesEntity(flowEdgesRequestBean, call))
+                .collect(Collectors.toList());
+        return flowEdgesRepository.saveAll(flowEdgesEntities);
+    }
+
+    public FlowEdgesEntity createFlowEdgesEntity(FlowEdgesRequestBean flowEdgesRequestBean,CallEntity call) {
+        FlowEdgesEntity flowEdgesEntity = new FlowEdgesEntity();
+        flowEdgesEntity.setTrackingId(flowEdgesRequestBean.getId());
+        flowEdgesEntity.setSourceId(Long.valueOf(flowEdgesRequestBean.getSource()));
+        flowEdgesEntity.setTargetId(Long.valueOf(flowEdgesRequestBean.getTarget()));
+        flowEdgesEntity.setType(flowEdgesRequestBean.getType());
+        flowEdgesEntity.setCallId(call.getId());
+        return flowEdgesEntity;
+    }
+
+    public FlowDataResponseBean convertFlowDataEntityToFlowDataResponseBean(FlowDataEntity flowDataEntity) {
+        FlowDataResponseBean flowDataResponseBean = new FlowDataResponseBean();
+        flowDataResponseBean.setId(flowDataEntity.getId());
+        flowDataResponseBean.setFormId(flowDataEntity.getFormId());
+        flowDataResponseBean.setChosenField(flowDataEntity.getChoosenField());
+        flowDataResponseBean.setChosenValue(flowDataEntity.getChoosenValue());
+        return flowDataResponseBean;
+    }
+
+    public FlowEdgesResponseBean convertFlowEdgesEntityToFlowEdgesResponseBean(FlowEdgesEntity flowEdgesEntity) {
+        FlowEdgesResponseBean flowEdgesResponseBean = new FlowEdgesResponseBean();
+        flowEdgesResponseBean.setId(flowEdgesEntity.getTrackingId());
+        flowEdgesResponseBean.setType(flowEdgesEntity.getType());
+        flowEdgesResponseBean.setSource(String.valueOf(flowEdgesEntity.getSourceId()));
+        flowEdgesResponseBean.setTarget(String.valueOf(flowEdgesEntity.getTargetId()));
+        return flowEdgesResponseBean;
+    }
+
+    public FlowResponseBean getFlowByCallId(Long callId){
+        CallEntity call= callService.validateCall(callId);
+        FlowResponseBean flowResponseBean=new FlowResponseBean();
+        List<FlowDataEntity> flowDataEntities=flowDataRepository.findByCallId(call.getId());
+        List<FlowEdgesEntity> flowEdgesEntities=flowEdgesRepository.findByCallId(call.getId());
+        List<FlowDataResponseBean> flowDataResponseBeans=createFlowDataResponseBean(flowDataEntities);
+        List<FlowEdgesResponseBean> flowEdgesResponseBeans=createFlowEdgesResponseBean(flowEdgesEntities);
+        flowResponseBean.setFlowData(flowDataResponseBeans);
+        flowResponseBean.setFlowEdges(flowEdgesResponseBeans);
+        if( flowResponseBean.getFlowEdges().isEmpty()){
+            return null;
+        }
+        flowResponseBean.setCallId(call.getId());
+        flowResponseBean.setCallStatus(CallStatusEnum.valueOf(call.getStatus()));
+        flowResponseBean.setInitialForm(call.getInitialForm());
+        flowResponseBean.setFinalForm(call.getFinalForm());
+        return flowResponseBean;
+    }
+
+}

src/main/java/net/gepafin/tendermanagement/dao/FlowFormDao.java

@@ -0,0 +1,354 @@
+package net.gepafin.tendermanagement.dao;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum;
+import net.gepafin.tendermanagement.repositories.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.ApplicationEntity;
+import net.gepafin.tendermanagement.entities.ApplicationFormEntity;
+import net.gepafin.tendermanagement.entities.ApplicationFormFieldEntity;
+import net.gepafin.tendermanagement.entities.FlowDataEntity;
+import net.gepafin.tendermanagement.entities.FlowEdgesEntity;
+import net.gepafin.tendermanagement.entities.FormEntity;
+import net.gepafin.tendermanagement.enums.FormActionEnum;
+import net.gepafin.tendermanagement.model.response.NextOrPreviousFormResponse;
+import net.gepafin.tendermanagement.service.FormService;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+
+@Component
+public class FlowFormDao {
+	
+	@Autowired
+	private FlowEdgesRepository flowEdgesRepository;
+	
+	@Autowired
+	private FlowDataRepository flowDataRepository;
+	
+	@Autowired
+	private ApplicationFormFieldRepository applicationFormFieldRepository;
+	
+	@Autowired
+	private ApplicationFormRepository applicationFormRepository;
+	
+	@Autowired
+	private ApplicationDao applicationDao;
+	
+	@Autowired
+	private FormService formService;
+	@Autowired
+	private FormDao formDao;
+
+
+	
+//	Long getNextForm(FormEntity currentFormEntity, ApplicationEntity applicationEntity) {
+//		// vlaidation if next form findout and cuuent from is not fill the give error
+//		List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findBySourceIdAndCallId(currentFormEntity.getId(), applicationEntity.getCall().getId());
+//		ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), currentFormEntity.getId());
+//		if(applicationFormEntity ==  null) {
+//			throw new CustomValidationException(Status.VALIDATION_ERROR,
+//					Translator.toLocale("current form is not fill"));
+//		}
+//		if(flowEdgesList.isEmpty()) {
+//			throw new ResourceNotFoundException(Status.NOT_FOUND,
+//					Translator.toLocale(GepafinConstant.NEXT_FORM_NOT_FOUND));
+//		} else if(flowEdgesList.size() == 1) {
+//			return flowEdgesList.get(0).getTargetId();
+//		} else {
+//			List<Long> nextFormIds = flowEdgesList.stream().map(FlowEdgesEntity::getTargetId).toList();
+//		  	FlowDataEntity flowDataEntity = flowDataRepository.findByFormIdAndCallId(currentFormEntity.getId(), applicationEntity.getCall().getId());
+//		  	
+//			ApplicationFormFieldEntity applicationFormFieldEntity = applicationFormFieldRepository
+//					.findByFieldIdAndApplicationFormFormIdAndApplicationFormApplicationId(flowDataEntity.getChoosenField(),
+//							currentFormEntity.getId(), applicationEntity.getId()).orElseThrow(()-> new ResourceNotFoundException(Status.NOT_FOUND,
+//									Translator.toLocale(GepafinConstant.NEXT_FORM_NOT_FOUND)));
+//			
+//			flowDataEntity = flowDataRepository.findByChoosenValueAndFormIdIn(applicationFormFieldEntity.getFieldValue(), nextFormIds).orElseThrow(()-> new NullPointerException());
+//			return flowDataEntity.getFormId();
+//		}
+//	}
+//	
+//	
+//	Long getPreviousForm(FormEntity currentFormEntity, ApplicationEntity applicationEntity) {
+//
+//	    // Step 1: Find all edges where the current form is the target (i.e., reverse flow)
+//	    List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByTargetIdAndCallId(
+//	            currentFormEntity.getId(), applicationEntity.getCall().getId());
+//
+//	    if (flowEdgesList.isEmpty()) {
+//	        // If no previous edges are found, return null or handle this case based on your needs
+//	    	throw new ResourceNotFoundException(Status.NOT_FOUND,
+//					Translator.toLocale(GepafinConstant.PREVIOUS_FORM_NOT_FOUND));
+//	    }
+//
+//	    // Step 2: If only one edge exists, return the source (previous) form ID directly  have to look into it
+//	    if (flowEdgesList.size() == 1) {
+//	        return flowEdgesList.get(0).getSourceId();
+//	    }
+//	    List<Long> previousFormIds = flowEdgesList.stream().map(FlowEdgesEntity::getSourceId).toList();
+//
+//	    
+//	    // Step 3: Try to find flow data for the current form. If not found, we know it's the last step (or no field filtering is needed).
+//	    List<FlowDataEntity> flowDataList = flowDataRepository.findByFormIdInAndCallId(
+//	    		previousFormIds, applicationEntity.getCall().getId());
+//	    
+//	    List<String> fieldValue = flowDataList.stream().map(FlowDataEntity::getChoosenValue).toList();
+//
+////	    if (flowDataEntity == null || flowDataEntity.getChoosenField() == null) {
+////	        // If flow data is not found, simply return the first matching previous form
+////	        return flowEdgesList.get(0).getSourceId();  // You can modify this logic if needed
+////	    }
+//
+//	    // Step 4: Fetch the field value from the application form fields
+//	    Set<FormEntity> formList = applicationFormFieldRepository
+//	            .findByFieldValueInAndAndApplicationFormApplicationId(
+//	            		fieldValue, applicationEntity.getId()).stream().map(applicationFormFieldEntity->applicationFormFieldEntity.getApplicationForm().getForm()).collect(Collectors.toSet());
+//	    
+//	    List<Long> fieldIds = formList.stream().map(formEntity->getNextForm(formEntity, applicationEntity)).toList();
+//	    for(Long formId:previousFormIds) {
+//	    	fieldIds.contains(formId);
+//	    	return formId;
+//	    }
+//	    return null;
+////	            .orElseThrow(() -> new NullPointerException("Field value not found for the current form and application."));
+//
+//	    
+////	    // Step 5: Check if there's a matching previous form based on the chosen value
+////	    FlowDataEntity previousFlowDataEntity = flowDataRepository.findByChoosenValueAndFormIdIn(
+////	            applicationFormFieldEntity.getFieldValue(), flowEdgesList.stream().map(FlowEdgesEntity::getSourceId).toList())
+////	            .orElse(null);  // If no matching form is found, return null or the first source form
+////
+////	    // Step 6: Return the formId of the matching previous form, or the first one if no specific match is found
+////	    return previousFlowDataEntity != null ? previousFlowDataEntity.getFormId() : flowEdgesList.get(0).getSourceId();
+//	}
+	
+	
+	public Long getNextForm(FormEntity currentFormEntity, ApplicationEntity applicationEntity) {
+	    // Validate if the current form has been filled
+	    ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(
+	            applicationEntity.getId(), currentFormEntity.getId());
+
+	    // Retrieve the flow edges for the next forms
+	    List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findBySourceIdAndCallId(
+	            currentFormEntity.getId(), applicationEntity.getCall().getId());
+
+	    if (flowEdgesList.isEmpty()) {
+	    	return null;
+//	        throw new ResourceNotFoundException(Status.NOT_FOUND,
+//	                Translator.toLocale(GepafinConstant.NEXT_FORM_NOT_FOUND));
+	    }
+
+	    // If only one edge exists, return the target form ID
+	    if (flowEdgesList.size() == 1) {
+	        return flowEdgesList.get(0).getTargetId();
+	    }
+	    
+	    if (applicationFormEntity == null) {
+	        throw new CustomValidationException(Status.VALIDATION_ERROR,
+	                Translator.toLocale(GepafinConstant.CURRENT_FORM_INCOMPLETE));
+	    }
+
+	    // For multiple edges, find the next form based on the chosen value
+	    List<Long> nextFormIds = flowEdgesList.stream()
+	            .map(FlowEdgesEntity::getTargetId)
+	            .toList();
+
+	    // Retrieve the flow data for the current form
+	    FlowDataEntity flowDataEntity = flowDataRepository.findByFormIdAndCallId(
+	            currentFormEntity.getId(), applicationEntity.getCall().getId());
+
+	    // Fetch the application form field related to the chosen field
+	    ApplicationFormFieldEntity applicationFormFieldEntity = applicationFormFieldRepository
+	            .findByFieldIdAndApplicationFormFormIdAndApplicationFormApplicationId(
+	                    flowDataEntity.getChoosenField(), currentFormEntity.getId(), applicationEntity.getId()).orElse(null);
+
+	    // Find the next form based on the chosen value and return its ID
+	    return flowDataRepository.findByChoosenValueAndFormIdIn(
+	            applicationFormFieldEntity.getFieldValue(), nextFormIds)
+	            .map(FlowDataEntity::getFormId)
+	            .orElse(null);
+	}
+	
+//	public Long getPreviousForm(FormEntity currentFormEntity, ApplicationEntity applicationEntity) {
+//	    // Retrieve the flow edges for the previous forms
+//	    List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByTargetIdAndCallId(
+//	            currentFormEntity.getId(), applicationEntity.getCall().getId());
+//
+//	    if (flowEdgesList.isEmpty()) {
+//	    	return null;
+////	        throw new ResourceNotFoundException(Status.NOT_FOUND,
+////	                Translator.toLocale(GepafinConstant.PREVIOUS_FORM_NOT_FOUND));
+//	    }
+//
+//	    // If only one edge exists, return the source form ID
+//	    if (flowEdgesList.size() == 1) {
+//	        return flowEdgesList.get(0).getSourceId();
+//	    }
+//
+//	    // For multiple edges, find the previous form based on the chosen value
+//	    List<Long> previousFormIds = flowEdgesList.stream()
+//	            .map(FlowEdgesEntity::getSourceId)
+//	            .toList();
+//
+//	    // Fetch the flow data based on previous form IDs
+//	    List<FlowDataEntity> flowDataList = flowDataRepository.findByFormIdInAndCallId(
+//	            previousFormIds, applicationEntity.getCall().getId());
+//
+//	    List<String> chosenValues = flowDataList.stream()
+//	            .map(FlowDataEntity::getChoosenValue)
+//	            .toList();
+//
+//	    // Fetch the previous forms based on the chosen field values
+//	    Set<FormEntity> formList = applicationFormFieldRepository
+//	            .findByFieldValueInAndApplicationFormApplicationId(chosenValues, applicationEntity.getId()).stream()
+//	            .map(fieldEntity -> fieldEntity.getApplicationForm().getForm())
+//	            .collect(Collectors.toSet());
+//
+//	    // Find next form IDs recursively for all forms in the formList
+//	    List<Long> fieldIds = formList.stream()
+//	            .map(formEntity -> getNextForm(formEntity, applicationEntity))
+//	            .toList();
+//
+//	    // Return the first matching previous form ID that corresponds to a next form
+//	    return previousFormIds.stream()
+//	            .filter(fieldIds::contains)
+//	            .findFirst().orElse(null);
+//	}
+
+	public Long getPreviousForm(FormEntity currentFormEntity, ApplicationEntity applicationEntity) {
+
+		List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByTargetIdAndCallId(
+				currentFormEntity.getId(), applicationEntity.getCall().getId());
+
+		if (flowEdgesList.isEmpty()) {
+			return null;
+//	        throw new ResourceNotFoundException(Status.NOT_FOUND,
+//	                Translator.toLocale(GepafinConstant.PREVIOUS_FORM_NOT_FOUND));
+	    }
+
+	    // // If only one edge exists, return the source form ID
+	    // if (flowEdgesList.size() == 1) {
+	    //     return flowEdgesList.get(0).getSourceId();
+	    // }
+
+	    // For multiple edges, find the previous form based on the chosen value
+		List<Long> previousFormIds = flowEdgesList.stream()
+				.map(FlowEdgesEntity::getSourceId)
+				.toList();
+
+		List<ApplicationFormEntity> applicationFormEntities=applicationFormRepository.findByFormIdInAndApplicationId(previousFormIds,applicationEntity.getId());
+
+		applicationFormEntities.sort(Comparator.comparing(ApplicationFormEntity::getCreatedDate).reversed());
+
+		return applicationFormEntities.isEmpty() ? null : applicationFormEntities.get(0).getForm().getId();
+	}
+	public NextOrPreviousFormResponse getnextOrPreviousForm(ApplicationEntity applicationEntity, Long formId,
+			FormActionEnum action) {
+		Long calculatedFormId = null;
+		FormEntity formEntity = null;
+		if (formId == null) {
+			calculatedFormId = getDefaultForm(applicationEntity);
+		} else {
+			if(action==null) {
+				throw new CustomValidationException(Status.VALIDATION_ERROR,
+						Translator.toLocale(GepafinConstant.ACTION_REQUIRED));
+			}
+//			formEntity = Optional
+//					.ofNullable(applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), formId))
+//					.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+//							Translator.toLocale(GepafinConstant.APPLICATION_FORM_NOT_FOUND)))
+//					.getForm();
+			formEntity = formService.validateForm(formId);
+
+			if (action.equals(FormActionEnum.NEXT)) {
+				calculatedFormId = getNextForm(formEntity, applicationEntity);
+			} else {
+				calculatedFormId = getPreviousForm(formEntity, applicationEntity);
+			}
+		}
+		NextOrPreviousFormResponse nextOrPreviousFormResponse = null;
+		if (calculatedFormId == null && formId == null) {
+			FormEntity form=formService.validateForm(applicationEntity.getCall().getInitialForm());
+			calculatedFormId=form.getId();
+		}
+		if (calculatedFormId == null) {
+			calculatedFormId=formId;
+		}
+		nextOrPreviousFormResponse = setNextOrPreviousResponse(calculatedFormId, applicationEntity);
+
+		return nextOrPreviousFormResponse;
+	}
+
+	private NextOrPreviousFormResponse setNextOrPreviousResponse(Long calculatedFormId, ApplicationEntity applicationEntity) {
+		NextOrPreviousFormResponse nextOrPreviousFormResponse = new NextOrPreviousFormResponse();
+		Integer completedSteps=0;
+		FormEntity formEntity = formService.validateForm(calculatedFormId);
+		nextOrPreviousFormResponse.setFormId(calculatedFormId);
+		nextOrPreviousFormResponse.setApplicationStatus(ApplicationStatusTypeEnum.valueOf(applicationEntity.getStatus()));
+		nextOrPreviousFormResponse.setApplicationFormResponse(
+				applicationDao.processForm(formEntity, applicationEntity));
+		nextOrPreviousFormResponse.setCallId(applicationEntity.getCall().getId());
+		nextOrPreviousFormResponse.setCallTitle(applicationEntity.getCall().getName());
+		
+		List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByCallId(applicationEntity.getCall().getId());
+		Long totalFormSteps = calculateTotalSteps(flowEdgesList);
+		Long currentStep = calculateCurrentStep(formEntity);
+		nextOrPreviousFormResponse.setTotalFormSteps(totalFormSteps);
+		completedSteps = getCompletedSteps(applicationEntity);
+		nextOrPreviousFormResponse.setCompletedSteps(Long.valueOf(completedSteps));
+		nextOrPreviousFormResponse.setCurrentStep(currentStep);
+		return nextOrPreviousFormResponse;
+	}
+
+	public Integer getCompletedSteps(ApplicationEntity applicationEntity) {
+		 Integer completedSteps=0;
+		List<ApplicationFormEntity> applicationFormList = applicationFormRepository.findByApplicationId(applicationEntity.getId());
+		List<ApplicationFormFieldEntity> applicationFormFieldEntities=new ArrayList<>();
+		for (ApplicationFormEntity applicationFormEntity:applicationFormList){
+			applicationFormFieldEntities=applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId());
+			Boolean isCompleted=formDao.validateCompletedSteps(applicationFormFieldEntities, applicationEntity, applicationFormEntity.getForm());
+			if(Boolean.TRUE.equals(isCompleted)){
+				completedSteps++;
+			}
+		}
+		return completedSteps;
+	}
+
+	public Long calculateCurrentStep(FormEntity formEntity) {
+		Long currentStep = 2l;
+		if (formEntity.getId().equals(formEntity.getCall().getInitialForm())) {
+			currentStep = 1l;
+		} else if (formEntity.getId().equals(formEntity.getCall().getFinalForm())) {
+			currentStep = 3l;
+		}
+		return currentStep;
+	}
+
+	public Long calculateTotalSteps(List<FlowEdgesEntity> flowEdgesList) {
+		Long totalFormSteps = 3l;
+		if (flowEdgesList.size() == 1) {
+			totalFormSteps = 2l;
+		}
+		return totalFormSteps;
+	}
+
+	private Long getDefaultForm(ApplicationEntity applicationEntity) {
+		List<ApplicationFormEntity> applicationFormList = applicationFormRepository.findByApplicationIdOrderByCreatedDateAsc(applicationEntity.getId());
+		if(applicationFormList.isEmpty()) {
+			return applicationEntity.getCall().getInitialForm();
+		}
+		if(applicationFormList.get(applicationFormList.size()-1).getForm().getId().equals(applicationEntity.getCall().getFinalForm())) {
+			return applicationEntity.getCall().getInitialForm(); 
+		}
+		return getNextForm(applicationFormList.get(applicationFormList.size()-1).getForm(), applicationEntity);
+	}
+	
+
+}

src/main/java/net/gepafin/tendermanagement/dao/FormDao.java

@@ -0,0 +1,279 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.*;
+import net.gepafin.tendermanagement.model.request.*;
+import net.gepafin.tendermanagement.model.response.ContentResponseBean;
+import net.gepafin.tendermanagement.model.response.FormResponseBean;
+import net.gepafin.tendermanagement.model.response.VatNumberResponseBean;
+import net.gepafin.tendermanagement.repositories.*;
+import net.gepafin.tendermanagement.service.CallService;
+import net.gepafin.tendermanagement.util.DateTimeUtil;
+import net.gepafin.tendermanagement.util.FieldValidator;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import java.text.MessageFormat;
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Component
+public class FormDao {
+
+    @Autowired
+    private FormRepository formRepository;
+
+    @Autowired
+    private CallService callService;
+
+    @Autowired
+    private ApplicationFormRepository applicationFormRepository;
+
+    @Autowired
+    private CallDao callDao;
+
+    @Autowired
+    private FlowDataRepository flowDataRepository;
+
+    @Autowired
+    private FlowEdgesRepository flowEdgesRepository;
+
+    @Autowired
+    private VatCheckDao vatCheckDao;
+
+    @Autowired
+    private CallRepository callRepository;
+
+    public FormEntity saveFormEntity(FormEntity formEntity){
+        formEntity=formRepository.save(formEntity);
+        return formEntity;
+    }
+
+    public FormEntity convertFormRequestToFormEntity(Long callId,FormRequest formRequest){
+        FormEntity formEntity=new FormEntity();
+        CallEntity callEntity=callService.getCallEntityById(callId);
+        formEntity.setCall(callEntity);
+        formEntity.setLabel(formRequest.getLabel());
+        formEntity.setContent(setContentResponseBean(formRequest.getContent()));
+        formEntity=saveFormEntity(formEntity);
+        return formEntity;
+    }
+    public FormResponseBean convertFormEntityToFormResponseBean(FormEntity formEntity){
+        FormResponseBean formResponseBean=new FormResponseBean();
+        formResponseBean.setId(formEntity.getId());
+        formResponseBean.setContent(Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class));
+        formResponseBean.setLabel(formEntity.getLabel());
+        formResponseBean.setCallId(formEntity.getCall().getId());
+        formResponseBean.setCallStatus(formEntity.getCall().getStatus());
+        return formResponseBean;
+    }
+    public FormResponseBean createForm(Long callId,FormRequest formRequest){
+        validateForm(formRequest);
+        CallEntity callEntity=callService.validateCall(callId);
+        List<FlowDataEntity> flowDataEntities=flowDataRepository.findByCallId(callId);
+        List<FlowEdgesEntity> flowEdgesEntities=flowEdgesRepository.findByCallId(callId);
+        if(Boolean.FALSE.equals(flowDataEntities.isEmpty() || flowDataEntities==null ) || Boolean.FALSE.equals(flowEdgesEntities.isEmpty() || flowEdgesEntities==null) ){
+            flowDataRepository.deleteAll(flowDataEntities);
+            flowEdgesRepository.deleteAll(flowEdgesEntities);
+            callEntity.setInitialForm(null);
+            callEntity.setFinalForm(null);
+            callRepository.save(callEntity);
+        }
+        FormEntity formEntity=convertFormRequestToFormEntity(callId,formRequest);
+        return convertFormEntityToFormResponseBean(formEntity);
+    }
+    public void validateForm(FormRequest formRequest){
+        if(formRequest.getContent()==null  || formRequest.getLabel()==null ){
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.REQUIRED_PARAMETER_NOT_FOUND_FOR_FORM));
+        }
+           }
+          public FormResponseBean updateForm(Long formId, FormRequest formRequest,Boolean forceDeleteFlow){
+        ContentRequestBean contentRequestBean2=null;
+        String choosenField=null;
+        FormEntity formEntity = validateForm(formId);
+           callDao.validateUpdate(formEntity.getCall());
+            List<ContentRequestBean> contentRequestBean = Utils.convertJsonStringToList(formEntity.getContent(), ContentRequestBean.class);
+            for (ContentRequestBean contentRequestBean1 : contentRequestBean) {
+                FlowDataEntity flowDataEntity = flowDataRepository.findByFormIdAndChoosenField(formEntity.getId(), contentRequestBean1.getId());
+                if (flowDataEntity != null) {
+                     choosenField = flowDataEntity.getChoosenField();
+                    if (Boolean.TRUE.equals(contentRequestBean1.getId().equals(choosenField))) {
+                        contentRequestBean2 = contentRequestBean1;
+                        break;
+                    }
+                }
+            }
+            if (contentRequestBean2 != null) {
+                List<SettingRequestBean> settingRequestBeansDB = contentRequestBean2.getSettings();
+                for (ContentRequestBean contentRequestBeanRequest : formRequest.getContent()) {
+                    if (contentRequestBeanRequest.getId().equals(contentRequestBean2.getId())) {
+                        for (SettingRequestBean settingRequestBeanRequest : contentRequestBeanRequest.getSettings()) {
+                            for (SettingRequestBean settingRequestBeanDB : settingRequestBeansDB) {
+                                if (settingRequestBeanRequest.getName().equals(settingRequestBeanDB.getName())) {
+                                    if (!settingRequestBeanRequest.getValue().equals(settingRequestBeanDB.getValue())) {
+                                        if (Boolean.TRUE.equals(forceDeleteFlow)) {
+                                            Utils.setIfUpdated(formEntity::getLabel, formEntity::setLabel, formRequest.getLabel());
+                                            Utils.setIfUpdated(formEntity::getContent, formEntity::setContent, setContentResponseBean(formRequest.getContent()));
+                                            formEntity.setUpdatedDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
+                                            formEntity = saveFormEntity(formEntity);
+                                            List<FlowDataEntity> flowDataEntities = flowDataRepository.findByCallId(formEntity.getCall().getId());
+                                            List<FlowEdgesEntity> flowEdgesEntities = flowEdgesRepository.findByCallId(formEntity.getCall().getId());
+                                            flowDataRepository.deleteAll(flowDataEntities);
+                                            flowEdgesRepository.deleteAll(flowEdgesEntities);
+                                            CallEntity callEntity = formEntity.getCall();
+                                            callEntity.setInitialForm(null);
+                                            callEntity.setFinalForm(null);
+                                            callRepository.save(callEntity);
+                                            return convertFormEntityToFormResponseBean(formEntity);
+                                        } else {
+                                            throw new CustomValidationException(
+                                                    Status.BAD_REQUEST,
+                                                    Translator.toLocale(GepafinConstant.UPDATING_FORM_VALUE_IMPACT_ON_FLOW, choosenField)
+                                            );
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+      else {
+            Utils.setIfUpdated(formEntity::getLabel, formEntity::setLabel, formRequest.getLabel());
+            Utils.setIfUpdated(formEntity::getContent, formEntity::setContent, setContentResponseBean(formRequest.getContent()));
+            formEntity.setUpdatedDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
+            formEntity = saveFormEntity(formEntity);
+            return convertFormEntityToFormResponseBean(formEntity);
+        }
+      return convertFormEntityToFormResponseBean(formEntity);
+    }
+
+    public FormEntity validateForm(Long formId) {
+        FormEntity formEntity = formRepository.findById(formId)
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.FORM_NOT_FOUND)));
+        return formEntity;
+    }
+
+    public FormResponseBean getFormEntityById(Long formId) {
+        FormEntity formEntity = validateForm(formId);
+     return  convertFormEntityToFormResponseBean(formEntity);
+    }
+    public void deleteFormById(Long formId){
+        FormEntity formEntity = validateForm(formId);
+        List<FlowDataEntity> flowDataEntities=flowDataRepository.findByCallId(formEntity.getCall().getId());
+        List<FlowEdgesEntity> flowEdgesEntities=flowEdgesRepository.findByCallId(formEntity.getCall().getId());
+        flowDataRepository.deleteAll(flowDataEntities);
+        flowEdgesRepository.deleteAll(flowEdgesEntities);
+        CallEntity callEntity=formEntity.getCall();
+        callEntity.setFinalForm(null);
+        callEntity.setInitialForm(null);
+        callRepository.save(callEntity);
+        formRepository.delete(formEntity);
+    }
+    public List<FormResponseBean> getFormsByCallId(Long callId){
+        CallEntity callEntity=callService.validateCall(callId);
+        if(callEntity== null){
+            throw new CustomValidationException(Status.VALIDATION_ERROR,
+                    Translator.toLocale(GepafinConstant.CALL_NOT_FOUND));
+        }
+        List<FormEntity> formEntities=formRepository.findByCallId(callId);
+        List<FormResponseBean> formResponseBeanList = formEntities.stream()
+                .map(req -> convertFormEntityToFormResponseBean(req))
+                .collect(Collectors.toList());
+        return formResponseBeanList;
+    }
+    public String setContentResponseBean(List<ContentRequestBean> contentRequestBeans){
+        return Utils.convertListToJsonString(contentRequestBeans);
+    }
+
+    public void validateFormField(List<ApplicationFormFieldRequestBean> applicationFormFieldRequestList, ApplicationEntity applicationEntity, FormEntity formEntity) {
+    	Map<String, Object> formFieldMap = new LinkedHashMap<String, Object>();
+    	for(ApplicationFormFieldRequestBean applicationFormFieldRequestBean:applicationFormFieldRequestList) {
+            if(applicationFormFieldRequestBean.getFieldValue()==null || applicationFormFieldRequestBean.getFieldValue().isEmpty())
+                continue;
+    		formFieldMap.put(applicationFormFieldRequestBean.getFieldId(),applicationFormFieldRequestBean.getFieldValue());
+    	}
+
+        FormResponseBean formResponseBean = convertFormEntityToFormResponseBean(formEntity);
+        ApplicationFormEntity applicationFormEntity=applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(),formEntity.getId());
+        Boolean isApplicationFormExist= getApplicationFormExist(applicationFormEntity);
+        FieldValidator validator = FieldValidator.create();
+        formResponseBean.getContent().forEach(contentResponseBean -> {
+            String fieldId = contentResponseBean.getId();
+            String value = (String) formFieldMap.get(fieldId);
+            String fieldLabel=contentResponseBean.getLabel();
+
+            if(value == null && isApplicationFormExist) {
+                return;
+            }
+            FieldValidatorBean fieldValidatorBean  = Utils.convertSourceObjectToDestinationObject(contentResponseBean.getValidators(), FieldValidatorBean.class);
+            validator
+                    .minLength(value, fieldValidatorBean.getMinLength(), fieldLabel)  // Only applies if minLength is not null
+                    .maxLength(value, fieldValidatorBean.getMaxLength(), fieldLabel)  // Only applies if maxLength is not null
+                    .matchesPattern(value, fieldValidatorBean.getPattern(), fieldLabel) // Only applies if pattern is present
+                    .validateCustom(value, fieldValidatorBean.getCustom(), fieldLabel);  // Add the custom validation here
+            if (fieldValidatorBean.getCustom() != null && fieldValidatorBean.getCustom().equals(GepafinConstant.IS_PIVA)) {
+               String error = validateVatNumber(value, fieldValidatorBean.getCustom(), fieldLabel);
+              if(error != null) {
+                  validator.addError(error);
+              }
+           }
+        });
+        validator.validate();
+    }
+
+    private Boolean getApplicationFormExist(ApplicationFormEntity applicationFormEntity) {
+        if(applicationFormEntity !=null) {
+            return true;
+        }
+        return false;
+    }
+
+    public Boolean validateCompletedSteps(List<ApplicationFormFieldEntity> applicationFormFieldEntityList, ApplicationEntity applicationEntity, FormEntity formEntity) {
+        Map<String, Object> formFieldMap = new LinkedHashMap<String, Object>();
+        for(ApplicationFormFieldEntity applicationFormFieldEntity:applicationFormFieldEntityList) {
+            formFieldMap.put(applicationFormFieldEntity.getFieldId(),applicationFormFieldEntity.getFieldValue());
+        }
+
+        FormResponseBean formResponseBean = convertFormEntityToFormResponseBean(formEntity);
+        FieldValidator validator = FieldValidator.create();
+        formResponseBean.getContent().forEach(contentResponseBean -> {
+            String fieldId = contentResponseBean.getId();
+            String value = (String) formFieldMap.get(fieldId);
+
+            FieldValidatorBean fieldValidatorBean  = Utils.convertSourceObjectToDestinationObject(contentResponseBean.getValidators(), FieldValidatorBean.class);
+            validator
+                    .isRequired(value,fieldValidatorBean.getIsRequired(),fieldId);
+        });
+        if (validator.hasErrors()) {
+            return false; // Validation failed, return false
+        }
+        return true;
+    }
+    public String validateVatNumber(String value,String customRule,String fieldId){
+        String error=null;
+
+        if (value!=null && value.matches("^\\d{1,11}$")) {
+            Map<String, Object> customData=null;
+            try {
+                Map<String, Object> vatCheckResponse = vatCheckDao.checkVatNumberApi(value);
+                if (Boolean.FALSE.equals(CollectionUtils.isEmpty(vatCheckResponse))) {
+                    customData = vatCheckResponse;
+                }
+            } catch (Exception e) {
+                error=(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_VALID_PIVA), fieldId));
+            }
+        }
+        return error;
+    }
+
+}

src/main/java/net/gepafin/tendermanagement/dao/FormFieldDao.java

@@ -0,0 +1,114 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.FormFieldEntity;
+import net.gepafin.tendermanagement.model.request.FormFieldRequest;
+import net.gepafin.tendermanagement.model.request.SettingRequestBean;
+import net.gepafin.tendermanagement.model.response.FormFieldResponseBean;
+import net.gepafin.tendermanagement.model.response.SettingResponseBean;
+import net.gepafin.tendermanagement.repositories.FormFieldRepository;
+import net.gepafin.tendermanagement.util.DateTimeUtil;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+public class FormFieldDao {
+
+	@Autowired
+	private FormFieldRepository formFieldRepository;
+
+	public FormFieldEntity convertFormFieldRequestToFormFieldEntity(FormFieldRequest formFieldRequest) {
+		FormFieldEntity formFieldEntity = new FormFieldEntity();
+		formFieldEntity.setLabel(formFieldRequest.getLabel());
+		formFieldEntity.setName(formFieldRequest.getName());
+		formFieldEntity.setDescription(formFieldRequest.getDescription());
+		formFieldEntity.setSortOrder(formFieldRequest.getSortOrder());
+		formFieldEntity.setValidators(Utils.convertMapIntoJsonString(formFieldRequest.getValidators()));
+		formFieldEntity.setSettings(setSettingRequestBean(formFieldRequest.getSettings()));
+		formFieldEntity = saveFormFieldEntity(formFieldEntity);
+		return formFieldEntity;
+	}
+
+	public FormFieldResponseBean convertFormFieldEntityToFormFieldResponseBean(FormFieldEntity formFieldEntity) {
+		FormFieldResponseBean formFieldResponseBean = new FormFieldResponseBean();
+		formFieldResponseBean.setId(formFieldEntity.getId());
+		formFieldResponseBean.setName(formFieldEntity.getName());
+		formFieldResponseBean.setDescription(formFieldEntity.getDescription());
+		formFieldResponseBean.setSortOrder(formFieldEntity.getSortOrder());
+		formFieldResponseBean
+				.setSettings(Utils.convertJsonStringToList(formFieldEntity.getSettings(), SettingResponseBean.class));
+		formFieldResponseBean.setLabel(formFieldEntity.getLabel());
+		formFieldResponseBean.setValidators(Utils.convertIntoJson(formFieldEntity.getValidators()));
+		return formFieldResponseBean;
+	}
+
+	public FormFieldEntity saveFormFieldEntity(FormFieldEntity formFieldEntity) {
+		formFieldEntity = formFieldRepository.save(formFieldEntity);
+		return formFieldEntity;
+	}
+
+	public void validateFormField(FormFieldRequest formFieldRequest) {
+		if (formFieldRequest.getSettings() == null || formFieldRequest.getLabel() == null) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.REQUIRED_PARAMETER_NOT_FOUND_FOR_FORM_FIELD));
+		}
+	}
+
+	public FormFieldResponseBean createFormField(FormFieldRequest formFieldRequest) {
+		validateFormField(formFieldRequest);
+		FormFieldEntity formFieldEntity = convertFormFieldRequestToFormFieldEntity(formFieldRequest);
+		return convertFormFieldEntityToFormFieldResponseBean(formFieldEntity);
+	}
+
+	public FormFieldResponseBean updateFormField(Long formFieldId, FormFieldRequest formFieldRequest) {
+		FormFieldEntity formFieldEntity = validateFormField(formFieldId);
+		Utils.setIfUpdated(formFieldEntity::getName, formFieldEntity::setName, formFieldRequest.getName());
+		Utils.setIfUpdated(formFieldEntity::getLabel, formFieldEntity::setLabel, formFieldRequest.getLabel());
+		Utils.setIfUpdated(formFieldEntity::getDescription, formFieldEntity::setDescription, formFieldRequest.getDescription());
+		Utils.setIfUpdated(formFieldEntity::getSortOrder, formFieldEntity::setSortOrder, formFieldRequest.getSortOrder());
+		Utils.setIfUpdated(formFieldEntity::getSettings, formFieldEntity::setSettings,
+				setSettingRequestBean(formFieldRequest.getSettings()));
+		Utils.setIfUpdated(formFieldEntity::getValidators, formFieldEntity::setValidators,
+				Utils.convertMapIntoJsonString(formFieldRequest.getValidators()));
+		formFieldEntity.setUpdatedDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
+		formFieldEntity = saveFormFieldEntity(formFieldEntity);
+		return convertFormFieldEntityToFormFieldResponseBean(formFieldEntity);
+	}
+
+	public FormFieldEntity validateFormField(Long formFieldId) {
+		FormFieldEntity formFieldEntity = formFieldRepository.findById(formFieldId)
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.FORM_FIELD_NOT_FOUND)));
+		return formFieldEntity;
+	}
+
+	public FormFieldResponseBean getFormFieldEntityById(Long formFieldId) {
+		FormFieldEntity formEntity = validateFormField(formFieldId);
+		return convertFormFieldEntityToFormFieldResponseBean(formEntity);
+	}
+
+	public void deleteFormById(Long formFieldId) {
+		FormFieldEntity formEntity = validateFormField(formFieldId);
+		formFieldRepository.delete(formEntity);
+	}
+
+	public String setSettingRequestBean(List<SettingRequestBean> settingRequestBeans) {
+		return Utils.convertListToJsonString(settingRequestBeans);
+	}
+
+	public List<FormFieldResponseBean> getAllFormField() {
+		List<FormFieldEntity> formFieldEntities = formFieldRepository.findAll();
+		List<FormFieldResponseBean> formFieldResponseBeans = formFieldEntities.stream()
+				.map(req -> convertFormFieldEntityToFormFieldResponseBean(req)).collect(Collectors.toList());
+		return formFieldResponseBeans;
+	}
+}

src/main/java/net/gepafin/tendermanagement/dao/FormTemplateDao.java

@@ -0,0 +1,102 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.FormTemplateEntity;
+import net.gepafin.tendermanagement.model.request.ContentRequestBean;
+import net.gepafin.tendermanagement.model.request.FormTemplateRequest;
+import net.gepafin.tendermanagement.model.response.ContentResponseBean;
+import net.gepafin.tendermanagement.model.response.FormTemplateResponseBean;
+import net.gepafin.tendermanagement.repositories.FormTemplateRepository;
+import net.gepafin.tendermanagement.util.DateTimeUtil;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+public class FormTemplateDao {
+
+	@Autowired
+	private FormTemplateRepository formTemplateRepository;
+
+	public FormTemplateEntity convertFormTemplateRequestToFormTemplateRequest(FormTemplateRequest formTemplateRequest) {
+		FormTemplateEntity formTemplateEntity = new FormTemplateEntity();
+		formTemplateEntity.setContent(setContentResponseBean(formTemplateRequest.getContent()));
+		formTemplateEntity.setLabel(formTemplateRequest.getLabel());
+		formTemplateEntity = saveFormTemplateEntity(formTemplateEntity);
+		return formTemplateEntity;
+	}
+
+	public FormTemplateEntity saveFormTemplateEntity(FormTemplateEntity formTemplateEntity) {
+		formTemplateEntity = formTemplateRepository.save(formTemplateEntity);
+		return formTemplateEntity;
+	}
+
+	public FormTemplateResponseBean convertFormTemplateEntityToFormTemplateResponseBean(
+			FormTemplateEntity formTemplateEntity) {
+		FormTemplateResponseBean formTemplateResponseBean = new FormTemplateResponseBean();
+		formTemplateResponseBean.setId(formTemplateEntity.getId());
+		formTemplateResponseBean
+				.setContent(Utils.convertJsonStringToList(formTemplateEntity.getContent(), ContentResponseBean.class));
+		formTemplateResponseBean.setLabel(formTemplateEntity.getLabel());
+		return formTemplateResponseBean;
+	}
+
+	public FormTemplateResponseBean createFormTemplate(FormTemplateRequest formTemplateRequest) {
+		validateFormTemplate(formTemplateRequest);
+		FormTemplateEntity formTemplateEntity = convertFormTemplateRequestToFormTemplateRequest(formTemplateRequest);
+		return convertFormTemplateEntityToFormTemplateResponseBean(formTemplateEntity);
+	}
+
+	public void validateFormTemplate(FormTemplateRequest formTemplateRequest) {
+		if (formTemplateRequest.getContent() == null || formTemplateRequest.getLabel() == null) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.REQUIRED_PARAMETER_NOT_FOUND_FOR_FORM_TEMPLATE));
+		}
+	}
+
+	public FormTemplateResponseBean updateFormTemplate(Long formTemplateId, FormTemplateRequest formTemplateRequest) {
+		FormTemplateEntity formTemplateEntity = validateFormTemplate(formTemplateId);
+		Utils.setIfUpdated(formTemplateEntity::getLabel, formTemplateEntity::setLabel, formTemplateRequest.getLabel());
+		Utils.setIfUpdated(formTemplateEntity::getContent, formTemplateEntity::setContent,
+				setContentResponseBean(formTemplateRequest.getContent()));
+		formTemplateEntity.setUpdatedDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
+		formTemplateEntity = saveFormTemplateEntity(formTemplateEntity);
+		return convertFormTemplateEntityToFormTemplateResponseBean(formTemplateEntity);
+	}
+
+	public FormTemplateEntity validateFormTemplate(Long formTemplateId) {
+		FormTemplateEntity formTemplateEntity = formTemplateRepository.findById(formTemplateId)
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.FORM_TEMPLATE_NOT_FOUND)));
+		return formTemplateEntity;
+	}
+
+	public FormTemplateResponseBean getFormTemplateEntityById(Long formTemplateId) {
+		FormTemplateEntity formTemplateEntity = validateFormTemplate(formTemplateId);
+		return convertFormTemplateEntityToFormTemplateResponseBean(formTemplateEntity);
+	}
+
+	public void deleteFormTemplateById(Long formTemplateId) {
+		FormTemplateEntity formTemplateEntity = validateFormTemplate(formTemplateId);
+		formTemplateRepository.delete(formTemplateEntity);
+	}
+
+	public String setContentResponseBean(List<ContentRequestBean> contentRequestBeans) {
+		return Utils.convertListToJsonString(contentRequestBeans);
+	}
+
+	public List<FormTemplateResponseBean> getAllFormTemplate() {
+		List<FormTemplateEntity> formTemplateEntities = formTemplateRepository.findAll();
+		List<FormTemplateResponseBean> formTemplateResponseBeans = formTemplateEntities.stream()
+				.map(req -> convertFormTemplateEntityToFormTemplateResponseBean(req)).collect(Collectors.toList());
+		return formTemplateResponseBeans;
+	}
+}

src/main/java/net/gepafin/tendermanagement/dao/LookUpDataDao.java

@@ -0,0 +1,109 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.entities.LookUpDataEntity;
+import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum;
+import net.gepafin.tendermanagement.model.request.LookUpDataReq;
+import net.gepafin.tendermanagement.model.request.LookUpDataRequest;
+import net.gepafin.tendermanagement.model.response.LookUpDataResponseBean;
+import net.gepafin.tendermanagement.repositories.LookUpDataRepository;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+
+@Component
+public class LookUpDataDao {
+
+    @Autowired
+    private LookUpDataRepository lookUpDataRepository;
+
+    public LookUpDataResponseBean createLookUpData(LookUpDataRequest lookUpDataReq) {
+        LookUpDataEntity entity = convertLookUpDataReqToLookUpDataEntity(lookUpDataReq);
+        return convertLookUpDataEntityToResponseBean(entity);
+    }
+    private LookUpDataEntity convertLookUpDataReqToLookUpDataEntity(LookUpDataRequest lookUpDataReq) {
+        LookUpDataEntity entity = new LookUpDataEntity();
+        entity.setTitle(lookUpDataReq.getTitle());
+        entity.setType(lookUpDataReq.getType().getValue());
+        entity.setValue(lookUpDataReq.getValue());
+        entity.setValue(lookUpDataReq.getResponse());
+        validateLookUpDataEntity(entity);
+        lookUpDataRepository.save(entity);
+        return entity;
+    }
+    
+    public void validateLookUpDataEntity(LookUpDataEntity entity) {
+        if (entity.getValue() == null || entity.getValue().trim().isEmpty()) {
+            throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.VALUE_CANNOT_BE_EMPTY));
+        }
+    }
+    
+    public LookUpDataEntity validateLookUpData(Long id) {
+    	return lookUpDataRepository.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.LOOKUP_DATA_NOT_FOUND)));
+    }
+
+    public LookUpDataResponseBean getLookUpDataById(Long id) {
+    	return convertLookUpDataEntityToResponseBean(validateLookUpData(id));
+    }
+
+    public LookUpDataResponseBean updateLookUpData(Long id, LookUpDataRequest lookUpDataReq) {
+        LookUpDataEntity entity = validateLookUpData(id);
+        setIfUpdated(entity::getTitle, entity::setTitle, lookUpDataReq.getTitle());
+        setIfUpdated(entity::getValue, entity::setValue, lookUpDataReq.getValue());
+        setIfUpdated(entity::getResponse, entity::setResponse, lookUpDataReq.getResponse());
+        lookUpDataRepository.save(entity);
+        return convertLookUpDataEntityToResponseBean(entity);
+    }
+
+    public void deleteLookUpData(Long id) {
+        LookUpDataEntity entity = validateLookUpData(id);
+        lookUpDataRepository.deleteById(entity.getId());
+    }
+
+    private LookUpDataResponseBean convertLookUpDataEntityToResponseBean(LookUpDataEntity entity) {
+        LookUpDataResponseBean response = new LookUpDataResponseBean();
+        response.setId(entity.getId());
+        response.setTitle(entity.getTitle());
+        response.setType(LookUpDataEntity.LookUpDataTypeEnum.valueOf(entity.getType()));
+        response.setValue(entity.getValue());
+        response.setResponse(entity.getResponse());
+        response.setCreatedDate(entity.getCreatedDate());
+        response.setUpdatedDate(entity.getUpdatedDate());
+        return response;
+    }
+
+    public List<LookUpDataResponseBean> getLookUpDataByTypes(List<LookUpDataTypeEnum> types) {
+        return types.stream()
+                .flatMap(type -> lookUpDataRepository.findByType(type.getValue()).stream())
+                .map(this::convertLookUpDataEntityToResponseBean)
+                .collect(Collectors.toList());
+    }
+    
+	public LookUpDataEntity getOrCreateLookUpDataEntity(LookUpDataReq req,
+			LookUpDataEntity.LookUpDataTypeEnum type) {
+		if (req.getLookUpDataId() == null || req.getLookUpDataId().equals(0l)) {
+			LookUpDataEntity newEntity = new LookUpDataEntity();
+			newEntity.setTitle(req.getTitle());
+			newEntity.setValue(req.getValue());
+			newEntity.setResponse(req.getResponse());
+			newEntity.setType(type.getValue());
+			validateLookUpDataEntity(newEntity);
+			return lookUpDataRepository.save(newEntity);
+		}
+
+		return lookUpDataRepository.findById(req.getLookUpDataId())
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.LOOK_UP_DATA_NOT_VALID_MSG)));
+	}
+
+
+}

src/main/java/net/gepafin/tendermanagement/dao/RegionDao.java

@@ -0,0 +1,133 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.RegionEntity;
+import net.gepafin.tendermanagement.enums.RegionStatusEnum;
+import net.gepafin.tendermanagement.model.request.RegionReq;
+import net.gepafin.tendermanagement.model.response.RegionResponseBean;
+import net.gepafin.tendermanagement.repositories.RegionRepository;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+
+@Repository
+public class RegionDao {
+    private final Logger log = LoggerFactory.getLogger(RegionDao.class);
+
+    @Autowired
+    private RegionRepository regionRepository;
+
+    public RegionResponseBean createRegion(RegionReq regionReq) {
+        log.info("Creating new region with details: {}", regionReq);
+        RegionEntity regionEntity = convertRegionRequestToRegionEntity(regionReq);
+        regionEntity = regionRepository.save(regionEntity);
+        log.info("Region created with ID: {}", regionEntity.getId());
+        return convertRegionEntityToRegionResponse(regionEntity);
+    }
+
+    private RegionEntity convertRegionRequestToRegionEntity(RegionReq regionReq) {
+        RegionEntity regionEntity = new RegionEntity();
+        regionEntity.setCountry(regionReq.getCountry());
+        regionEntity.setDescription(regionReq.getDescription());
+        regionEntity.setGdp(regionReq.getGdp());
+        regionEntity.setRegionName(regionReq.getRegionName());
+        regionEntity.setAreaSize(regionReq.getAreaSize());
+        regionEntity.setPopulation(regionReq.getPopulation());
+        regionEntity.setEnvironmentalScore(regionReq.getEnvironmentalScore());
+        regionEntity.setStatus(regionReq.getStatus().getValue());
+        regionEntity.setHealthcareAccess(regionReq.getHealthcareAccess());
+        regionEntity.setInfrastructureScore(regionReq.getInfrastructureScore());
+        regionEntity.setPriorityArea(regionReq.getPriorityArea());
+        regionEntity.setUnemploymentRate(regionReq.getUnemploymentRate());
+        regionEntity.setEducationLevel(regionReq.getEducationLevel());
+        return regionEntity;
+    }
+
+    public RegionResponseBean convertRegionEntityToRegionResponse(RegionEntity regionEntity) {
+        RegionResponseBean regionResponseBean = new RegionResponseBean();
+        regionResponseBean.setId(regionEntity.getId());
+        regionResponseBean.setCreatedDate(regionEntity.getCreatedDate());
+        regionResponseBean.setUpdatedDate(regionEntity.getUpdatedDate());
+        regionResponseBean.setCountry(regionEntity.getCountry());
+        regionResponseBean.setDescription(regionEntity.getDescription());
+        regionResponseBean.setGdp(regionEntity.getGdp());
+        regionResponseBean.setRegionName(regionEntity.getRegionName());
+        regionResponseBean.setAreaSize(regionEntity.getAreaSize());
+        regionResponseBean.setPopulation(regionEntity.getPopulation());
+        regionResponseBean.setEnvironmentalScore(regionEntity.getEnvironmentalScore());
+        regionResponseBean.setStatus(RegionStatusEnum.valueOf(regionEntity.getStatus()));
+        regionResponseBean.setHealthcareAccess(regionEntity.getHealthcareAccess());
+        regionResponseBean.setInfrastructureScore(regionEntity.getInfrastructureScore());
+        regionResponseBean.setPriorityArea(regionEntity.getPriorityArea());
+        regionResponseBean.setUnemploymentRate(regionEntity.getUnemploymentRate());
+        regionResponseBean.setEducationLevel(regionEntity.getEducationLevel());
+        return regionResponseBean;
+    }
+
+    public RegionResponseBean updateRegion(Long id, RegionReq regionReq) {
+        log.info("Updating region with ID: {}", id);
+        RegionEntity existingRegion = validateRegion(id);
+        log.info("Current region details: {}", existingRegion);
+        log.info("New region details: {}", regionReq);
+        String newStatus = regionReq.getStatus() != null ? regionReq.getStatus().getValue() : null;
+        if (Boolean.FALSE.equals(existingRegion.getStatus().equals(newStatus))) {
+            existingRegion.setStatus(newStatus);
+        }
+        setIfUpdated(existingRegion::getRegionName, existingRegion::setRegionName, regionReq.getRegionName());
+        setIfUpdated(existingRegion::getDescription, existingRegion::setDescription, regionReq.getDescription());
+        setIfUpdated(existingRegion::getCountry, existingRegion::setCountry, regionReq.getCountry());
+        setIfUpdated(existingRegion::getPriorityArea, existingRegion::setPriorityArea, regionReq.getPriorityArea());
+        setIfUpdated(existingRegion::getPopulation, existingRegion::setPopulation, regionReq.getPopulation());
+        setIfUpdated(existingRegion::getAreaSize, existingRegion::setAreaSize, regionReq.getAreaSize());
+        setIfUpdated(existingRegion::getGdp, existingRegion::setGdp, regionReq.getGdp());
+        setIfUpdated(existingRegion::getUnemploymentRate, existingRegion::setUnemploymentRate, regionReq.getUnemploymentRate());
+        setIfUpdated(existingRegion::getInfrastructureScore, existingRegion::setInfrastructureScore, regionReq.getInfrastructureScore());
+        setIfUpdated(existingRegion::getEducationLevel, existingRegion::setEducationLevel, regionReq.getEducationLevel());
+        setIfUpdated(existingRegion::getHealthcareAccess, existingRegion::setHealthcareAccess, regionReq.getHealthcareAccess());
+        setIfUpdated(existingRegion::getEnvironmentalScore, existingRegion::setEnvironmentalScore, regionReq.getEnvironmentalScore());
+
+        existingRegion = regionRepository.save(existingRegion);
+
+        log.info("Region updated with ID: {}", existingRegion.getId());
+        return Utils.convertObject(existingRegion, RegionResponseBean.class);
+    }
+
+    public RegionEntity validateRegion(Long id) {
+        log.info("Fetching region with ID: {}", id);
+        RegionEntity regionEntity = regionRepository.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.REGION_NOT_FOUND_MSG)));
+        log.info("Region found: {}", regionEntity);
+        return regionEntity;
+    }
+    public RegionResponseBean getRegionById(Long id) {
+        log.info("Fetching region with ID: {}", id);
+        RegionEntity regionEntity = validateRegion(id);
+        return convertRegionEntityToRegionResponse(regionEntity);
+    }
+    public void deleteById(Long id) {
+        log.info("Deleting region with ID: {}", id);
+        validateRegion(id);
+        regionRepository.deleteById(id);
+        log.info("Region deleted with ID: {}", id);
+    }
+
+    public List<RegionResponseBean> getAllRegions() {
+        log.info("Fetching all regions");
+        List<RegionResponseBean> regions = regionRepository.findAll()
+                .stream()
+                .map(regionEntity -> Utils.convertObject(regionEntity, RegionResponseBean.class))
+                .collect(Collectors.toList());
+        log.info("Total regions found: {}", regions.size());
+        return regions;
+    }
+}

src/main/java/net/gepafin/tendermanagement/dao/RoleDao.java

@@ -0,0 +1,127 @@
+package net.gepafin.tendermanagement.dao;
+
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.RegionEntity;
+import net.gepafin.tendermanagement.entities.RoleEntity;
+import net.gepafin.tendermanagement.enums.RoleStatusEnum;
+import net.gepafin.tendermanagement.model.request.RoleReq;
+import net.gepafin.tendermanagement.model.response.RegionResponseBean;
+import net.gepafin.tendermanagement.model.response.RoleResponseBean;
+import net.gepafin.tendermanagement.repositories.RoleRepository;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+
+@Component
+public class RoleDao {
+    private final Logger log = LoggerFactory.getLogger(RoleDao.class);
+
+    @Autowired
+    private RoleRepository roleRepository;
+
+    @Autowired
+    private RegionDao regionDao;
+    
+    public RoleResponseBean createRole(RoleReq roleReq) {
+        log.info("Creating new role with details: {}", roleReq);
+        RoleEntity roleEntity = convertRoleRequestToRoleEntity(roleReq);
+        roleEntity = roleRepository.save(roleEntity);
+        log.info("Role created with ID: {}", roleEntity.getId());
+        return convertRoleEntityToRoleResponse(roleEntity);
+    }
+
+    private RoleEntity convertRoleRequestToRoleEntity(RoleReq roleReq) {
+        RoleEntity roleEntity = new RoleEntity();
+        roleEntity.setRoleName(roleReq.getRoleName());
+        roleEntity.setRoleType(roleReq.getRoleType());
+        roleEntity.setPermissions(String.join(",", roleReq.getPermissions()));
+        roleEntity.setDescription(roleReq.getDescription());
+        RegionEntity regionEntity =regionDao.validateRegion(roleReq.getRegionId());
+        roleEntity.setRegion(regionEntity);
+        return roleEntity;
+    }
+
+    public RoleResponseBean convertRoleEntityToRoleResponse(RoleEntity roleEntity) {
+        
+        RoleResponseBean roleResponseBean = new RoleResponseBean();
+        roleResponseBean.setId(roleEntity.getId());
+        roleResponseBean.setCreatedDate(roleEntity.getCreatedDate());
+        roleResponseBean.setUpdatedDate(roleEntity.getUpdatedDate());
+        roleResponseBean.setRoleName(roleEntity.getRoleName());
+        roleResponseBean.setRoleType(roleEntity.getRoleType());
+        roleResponseBean.setDescription(roleEntity.getDescription());
+        String permissionsString = roleEntity.getPermissions();
+        List<String> permissionsList = permissionsString != null && !permissionsString.isEmpty()
+                ? Arrays.asList(permissionsString.split(","))
+                : new ArrayList<>();
+        roleResponseBean.setPermissions(permissionsList);
+        RegionResponseBean regionResponseBean = regionDao.convertRegionEntityToRegionResponse(roleEntity.getRegion());
+        roleResponseBean.setRegion(regionResponseBean);
+        return roleResponseBean;
+    }
+
+    public RoleResponseBean updateRole(Long id, RoleReq roleReq) {
+        log.info("Updating role with ID: {}", id);
+        RoleEntity existingRole = validateRole(id);
+
+        // Log changes before update
+        log.info("Current role details: {}", existingRole);
+        log.info("New role details: {}", roleReq);
+
+        setIfUpdated(existingRole::getRoleName, existingRole::setRoleName, roleReq.getRoleName());
+        setIfUpdated(existingRole::getRoleType, existingRole::setRoleType, roleReq.getRoleType());
+        setIfUpdated(existingRole::getDescription, existingRole::setDescription, roleReq.getDescription());
+        setIfUpdated(existingRole::getPermissions, existingRole::setPermissions, String.join(",", roleReq.getPermissions()));
+
+        existingRole = roleRepository.save(existingRole);
+
+        log.info("Role updated with ID: {}", existingRole.getId());
+        return Utils.convertObject(existingRole, RoleResponseBean.class);
+    }
+
+    public RoleEntity validateRole(Long id) {
+        log.info("Fetching role with ID: {}", id);
+        RoleEntity roleEntity = roleRepository.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.ROLE_NOT_FOUND)));
+        log.info("Role found: {}", roleEntity);
+        return roleEntity;
+    }
+    public RoleResponseBean getRoleById(Long id) {
+        log.info("Fetching role with ID: {}", id);
+        RoleEntity roleEntity = validateRole(id);
+        log.info("Role found: {}", roleEntity);
+        return convertRoleEntityToRoleResponse(roleEntity);
+    }
+    public void deleteById(Long id) {
+        log.info("Deleting role with ID: {}", id);
+        validateRole(id);
+        roleRepository.deleteById(id);
+        log.info("Role deleted with ID: {}", id);
+    }
+
+    public List<RoleResponseBean> getAllRoles() {
+        log.info("Fetching all roles");
+        List<RoleResponseBean> roles = roleRepository.findAll()
+                .stream()
+                .map(this::convertRoleEntityToRoleResponse)
+                .collect(Collectors.toList());
+        log.info("Total roles found: {}", roles.size());
+        return roles;
+    }
+    
+    public RoleEntity getRoleByType(RoleStatusEnum roleStatus) {
+        return roleRepository.findByRoleType(roleStatus.getValue());  
+    }
+}

src/main/java/net/gepafin/tendermanagement/dao/UserDao.java

@@ -0,0 +1,292 @@
+package net.gepafin.tendermanagement.dao;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import net.gepafin.tendermanagement.config.Translator;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.entities.RoleEntity;
+import net.gepafin.tendermanagement.entities.UserEntity;
+import net.gepafin.tendermanagement.enums.RoleStatusEnum;
+import net.gepafin.tendermanagement.enums.UserStatusEnum;
+import net.gepafin.tendermanagement.model.request.*;
+import net.gepafin.tendermanagement.model.response.RoleResponseBean;
+import net.gepafin.tendermanagement.model.response.UserSamlResponse;
+import net.gepafin.tendermanagement.model.response.UserResponseBean;
+import net.gepafin.tendermanagement.model.util.JWTToken;
+import net.gepafin.tendermanagement.repositories.UserRepository;
+import net.gepafin.tendermanagement.service.impl.AuthenticationService;
+import net.gepafin.tendermanagement.util.Utils;
+import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
+import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
+import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Repository;
+
+import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;
+
+import java.util.regex.Pattern;
+
+@Repository
+public class UserDao {
+
+    private final Logger log = LoggerFactory.getLogger(UserDao.class);
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private AuthenticationService authService;
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    @Autowired
+    private RoleDao roleDao;
+
+    public JWTToken createUser(HttpServletRequest request, String tempToken, UserReq userReq) {
+    	
+		if (Boolean.FALSE.equals(isValidEmail(userReq.getEmail()))) {
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.VALIDATE_EMAIL));
+		}
+		log.info("Creating user with email: {}", userReq.getEmail());
+		if (userRepository.existsByEmailIgnoreCase(userReq.getEmail())) {
+			log.error("User creation failed: Email {} already exists", userReq.getEmail());
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.EMAIL_ALREADY_EXISTS));
+		}
+		if (Boolean.FALSE.equals(StringUtils.isEmpty(userReq.getCodiceFiscale()))
+				&& userRepository.existsByCodiceFiscale(userReq.getCodiceFiscale())) {
+			log.error("User creation failed: CodiceFiscale {} already exists", userReq.getCodiceFiscale());
+			throw new CustomValidationException(Status.VALIDATION_ERROR,
+					Translator.toLocale(GepafinConstant.CODICE_FISCALE_EXISTS));
+		}
+		if (tempToken == null && userReq.getRoleId() == null) {
+				throw new ResourceNotFoundException(Status.VALIDATION_ERROR,
+						Translator.toLocale(GepafinConstant.ROLE_ID_MANDATORY));
+		}
+		if(tempToken != null) 	{
+				userReq.setRoleId(null);
+		}
+		validatePassword(userReq.getPassword(), userReq.getConfPassword(), tempToken);
+        
+        UserEntity userEntity = convertUserRequestToUserEntity(userReq);
+        userEntity = userRepository.save(userEntity);
+        log.info("User created with ID: {}", userEntity.getId());
+        return authService.getJWTTokenBean(userEntity, Boolean.TRUE);
+    }
+    
+    private void validatePassword(String password, String confirmPassword, String tempToken) {
+        if (StringUtils.isEmpty(password) || StringUtils.isEmpty(confirmPassword)) {
+        	if(tempToken == null) {        		
+        		throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.VALIDATE_PASSWORD));
+        	}else if(Boolean.FALSE.equals(StringUtils.isEmpty(password) && StringUtils.isEmpty(confirmPassword))){
+        		throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.VALIDATE_PASSWORD));
+        	}
+        }
+
+        if (password != null && !password.equals(confirmPassword)) {
+            log.error("User creation failed: Passwords do not match");
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.PASSWORD_DOESNT_MATCH));
+        }
+
+        if (password != null && password.length() < 8) {
+            log.error("User creation failed: Password length is less than 8 characters");
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.PASSWORD_MIN_LEN));
+        }
+    }
+
+    public UserResponseBean updateUser(Long userId, UpdateUserReq userReq) {
+        log.info("Updating user with ID: {}", userId);
+        UserEntity userEntity=validateUser(userId);
+        log.info("Current user details: {}", userEntity);
+        log.info("New user details: {}", userReq);
+        String newStatus = userReq.getStatus() != null ? userReq.getStatus().getValue() : null;
+        if (Boolean.FALSE.equals(userEntity.getStatus().equals(newStatus))) {
+            userEntity.setStatus(newStatus);
+        }
+        setIfUpdated(userEntity::getFirstName, userEntity::setFirstName, userReq.getFirstName());
+        setIfUpdated(userEntity::getLastName, userEntity::setLastName, userReq.getLastName());
+        setIfUpdated(userEntity::getOrganization, userEntity::setOrganization, userReq.getOrganization());
+        setIfUpdated(userEntity::getAddress, userEntity::setAddress, userReq.getAddress());
+        setIfUpdated(userEntity::getPhoneNumber, userEntity::setPhoneNumber, userReq.getPhoneNumber());
+        if (userReq.getRoleId() != null) {
+            RoleEntity roleEntity = roleDao.validateRole(userReq.getRoleId());
+            setIfUpdated(userEntity::getRoleEntity, userEntity::setRoleEntity, roleEntity);
+        }
+        userEntity = userRepository.save(userEntity);
+        log.info("User updated with ID: {}", userEntity.getId());
+        return convertUserEntityToUserResponse(userEntity);
+    }
+
+    private UserEntity convertUserRequestToUserEntity(UserReq userReq) {
+        UserEntity userEntity = new UserEntity();
+        if(Boolean.FALSE.equals(StringUtils.isEmpty(userReq.getPassword()))) {
+        	userEntity.setPassword(passwordEncoder.encode(userReq.getPassword()));
+        }
+        userEntity.setEmail(userReq.getEmail());
+        userEntity.setFirstName(userReq.getFirstName());
+        userEntity.setStatus(UserStatusEnum.ACTIVE.getValue());
+        userEntity.setLastName(userReq.getLastName());
+        userEntity.setOrganization(userReq.getOrganization());
+        userEntity.setAddress(userReq.getAddress());
+        userEntity.setPhoneNumber(userReq.getPhoneNumber());
+        userEntity.setRoleEntity(getRoleEntity(userReq.getRoleId()));
+        userEntity.setCodiceFiscale(userReq.getCodiceFiscale());
+        userEntity.setDateOfBirth(userReq.getDateOfBirth());
+        return userEntity;
+    }
+
+    private RoleEntity getRoleEntity(Long roleId) {
+		if(roleId != null) {
+			return roleDao.validateRole(roleId);
+		} else {
+			return roleDao.getRoleByType(RoleStatusEnum.ROLE_BENEFICIARY);
+		}
+	}
+
+	private UserResponseBean convertUserEntityToUserResponse(UserEntity userEntity) {
+        UserResponseBean userResponseBean = new UserResponseBean();
+        userResponseBean.setId(userEntity.getId());
+        userResponseBean.setCreatedDate(userEntity.getCreatedDate());
+        userResponseBean.setUpdatedDate(userEntity.getUpdatedDate());
+        userResponseBean.setEmail(userEntity.getEmail());
+        userResponseBean.setFirstName(userEntity.getFirstName());
+        userResponseBean.setLastName(userEntity.getLastName());
+        userResponseBean.setPhoneNumber(userEntity.getPhoneNumber());
+        userResponseBean.setOrganization(userEntity.getOrganization());
+        userResponseBean.setAddress(userEntity.getAddress());
+        userResponseBean.setCity(userEntity.getCity());
+        userResponseBean.setCountry(userEntity.getCountry());
+        userResponseBean.setStatus(UserStatusEnum.valueOf(userEntity.getStatus()));
+        RoleResponseBean roleResponseBean = roleDao.convertRoleEntityToRoleResponse(userEntity.getRoleEntity());
+        userResponseBean.setRole(roleResponseBean);
+        userResponseBean.setLastLogin(userEntity.getLastLogin());
+        userResponseBean.setCodiceFiscale(userEntity.getCodiceFiscale());
+        userResponseBean.setDateOfBirth(userEntity.getDateOfBirth());
+        return userResponseBean;
+    }
+
+    public UserResponseBean getUserById(Long id) {
+        log.info("Fetching user with ID: {}", id);
+        UserEntity userEntity=validateUser(id);
+//        if (!UserStatusEnum.ACTIVE.getValue().equals(userEntity.getStatus())) {
+//            log.info("User with ID: {} is not active", id);
+//            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG));
+//        }
+        log.info("User found: {}", userEntity);
+        return convertUserEntityToUserResponse(userEntity);
+    }
+
+    public void deleteUser(Long id) {
+        log.info("Deleting user with ID: {}", id);
+        validateUser(id);
+        userRepository.deleteById(id);
+        log.info("User deleted with ID: {}", id);
+    }
+
+    public JWTToken login(LoginReq loginReq) {
+        log.info("User login attempt for email: {}", loginReq.getEmail());
+        JWTToken jwtToken = authService.login(loginReq);
+        log.info("Login successful for email: {}", loginReq.getEmail());
+        return jwtToken;
+    }
+
+	public UserEntity validateUser(Long userId) {
+		return userRepository.findById(userId)
+				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
+						Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG)));
+	}
+
+    public String initiatePasswordReset(InitiatePasswordResetReq resetReq) {
+        UserEntity user = userRepository.findByEmail(resetReq.getEmail());
+        if (user == null) {
+            log.info("Password reset attempt for non-existent user: {}", resetReq.getEmail());
+            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG));
+        }
+        String token = Utils.generateSecureToken();
+        user.setResetPasswordToken(token);
+        userRepository.save(user);
+        log.info("Password reset token generated for user: {}", resetReq.getEmail());
+        return token;
+    }
+
+    public Boolean resetPassword(ResetPasswordReq resetPasswordReq) {
+        UserEntity user = userRepository.findByEmail(resetPasswordReq.getEmail());
+        if (user == null) {
+            log.info("Password reset attempt for non-existent user: {}", resetPasswordReq.getEmail());
+            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG));
+        }
+        if (!resetPasswordReq.getNewPassword().equals(resetPasswordReq.getConfirmPassword())) {
+            log.info("User creation failed: Passwords do not match for email {}", user.getEmail());
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.PASSWORD_DOESNT_MATCH));
+        }
+        String dbToken = user.getResetPasswordToken();
+
+        if (dbToken == null || !dbToken.equals(resetPasswordReq.getToken())) {
+            log.info("Invalid password reset token for user: {}", resetPasswordReq.getEmail());
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.INVALID_TOKEN_MSG));
+        }
+
+        user.setPassword(passwordEncoder.encode(resetPasswordReq.getNewPassword()));
+        user.setResetPasswordToken(null);
+        userRepository.save(user);
+        log.info("Password successfully reset for user: {}", resetPasswordReq.getEmail());
+        return true;
+    }
+
+    public Boolean changePassword(ChangePasswordRequest request) {
+        UserEntity user = userRepository.findByEmail(request.getEmail());
+        if (user == null) {
+            log.info("Password reset attempt for non-existent user: {}", request.getEmail());
+            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG));
+        }
+        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
+            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.CURRENT_PASSWORD_INCORRECT));
+        }
+        if (!request.getNewPassword().equals(request.getConfirmPassword())) {
+            log.info("User creation failed: Passwords do not match for email {}", user.getEmail());
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.PASSWORD_DOESNT_MATCH));
+        }
+        user.setPassword(passwordEncoder.encode(request.getNewPassword()));
+        userRepository.save(user);
+        return true;
+    }
+    public void logout(HttpServletRequest request, HttpServletResponse response) {
+        authService.logout(request, response);
+        log.info("User successfully logged out.");
+    }
+    
+	    
+	public static Boolean isValidEmail(String email) {
+		String EMAIL_REGEX = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
+		if (email == null || email.isEmpty()) {
+			return false;
+		}
+		Pattern pattern = Pattern.compile(EMAIL_REGEX);
+		return pattern.matcher(email).matches();
+	}
+
+    public UserResponseBean updateUserStatus(Long userId, UserStatusEnum statusReq) {
+        log.info("Updating status for user with ID: {}", userId);
+        UserEntity userEntity=validateUser(userId);
+        userEntity.setStatus(statusReq.getValue());
+        userEntity = userRepository.save(userEntity);
+        log.info("User status updated to {} for user ID: {}", statusReq, userId);
+        return convertUserEntityToUserResponse(userEntity);
+    }
+
+	public JWTToken validateExistingUserToken(String token) {
+		return authService.validateExistingUserToken(token);
+	}
+
+	public UserSamlResponse validateNewUserToken(String token) {
+		return authService.validateNewUserToken(token);
+	}
+
+}

src/main/java/net/gepafin/tendermanagement/dao/VatCheckDao.java

@@ -0,0 +1,74 @@
+package net.gepafin.tendermanagement.dao;
+
+import feign.FeignException;
+import net.gepafin.tendermanagement.constants.GepafinConstant;
+import net.gepafin.tendermanagement.service.feignClient.VatCheckService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+
+import java.net.URI;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@Component
+public class VatCheckDao {
+
+    @Autowired
+    private VatCheckService vatCheckService;
+
+    @Value("${vatCheckNewToken}")
+    public String vatCheckNewToken;
+
+    @Value("${isVatCheckGloballyDisabled}")
+    public String isVatCheckGloballyDisabled;
+
+    public final Logger log = LoggerFactory.getLogger(VatCheckDao.class);
+
+
+
+    public Map<String, Object> checkVatNumberApi(String vatNumber) {
+        if (Boolean.TRUE.equals(Boolean.parseBoolean(isVatCheckGloballyDisabled))) {
+            return new HashMap<>();
+        }
+        Map<String, Object> responseBody = new HashMap<>();
+        try {
+            HttpHeaders headers = new HttpHeaders();
+            headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.set(GepafinConstant.AUTHORIZATION, "Bearer " + vatCheckNewToken);
+            headers.add(org.apache.http.HttpHeaders.USER_AGENT,
+                    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0");
+
+            URI baseUrl = URI.create(GepafinConstant.CHECK_VATNUMBER_V2_NEW_URL);
+            ResponseEntity<Map<String, Object>> response = vatCheckService.checkVatNumber(baseUrl,vatNumber, headers);
+
+            if (response.getStatusCode() == HttpStatus.OK && response.hasBody()) {
+                log.info("Successfully checked vat number");
+                Map<String, Object> responseMap = response.getBody();
+                if (responseMap != null && responseMap.containsKey("data")) {
+                    responseBody = (Map<String, Object>) responseMap.get("data");
+                    responseBody.remove("timestamp_creation");
+                    responseBody.remove("timestamp_last_update");
+                    responseBody.remove("data_iscrizione");
+                    responseBody.remove("id");
+                    Map<String, Object> data = new LinkedHashMap<>();
+                    data.put("data", responseBody);
+                    return data;
+                }
+            }
+        } catch (FeignException ex) {
+            log.error("Exception occurred while checking vat number: {0}", ex);
+            throw ex;
+        }
+        return responseBody;
+    }
+}

src/main/java/net/gepafin/tendermanagement/entities/ApplicationEntity.java

@@ -0,0 +1,36 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "APPLICATION")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ApplicationEntity extends BaseEntity {
+
+    @ManyToOne
+    @JoinColumn(name = "USER_ID", nullable = false)
+    private UserEntity user;
+
+    @Column(name = "SUBMISSION_DATE")
+    private LocalDateTime submissionDate;
+
+    @Column(name = "STATUS", length = 255)
+    private String status;
+
+    @Column(name = "COMMENTS", columnDefinition = "TEXT")
+    private String comments;
+
+    @ManyToOne
+    @JoinColumn(name = "CALL_ID", nullable = false)
+    private CallEntity call;
+
+    @Column(name="IS_DELETED")
+    private Boolean isDeleted;
+
+    }

src/main/java/net/gepafin/tendermanagement/entities/ApplicationFormEntity.java

@@ -0,0 +1,20 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+
+@Entity
+@Table(name = "APPLICATION_FORM")
+@Data
+public class ApplicationFormEntity extends BaseEntity {
+
+    @ManyToOne
+    @JoinColumn(name = "APPLICATION_ID", nullable = false)
+    private ApplicationEntity application;
+
+    @ManyToOne
+    @JoinColumn(name = "FORM_ID", nullable = false)
+    private FormEntity form;
+
+}

src/main/java/net/gepafin/tendermanagement/entities/ApplicationFormFieldEntity.java

@@ -0,0 +1,27 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "APPLICATION_FORM_FIELD")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ApplicationFormFieldEntity extends BaseEntity {
+
+    @ManyToOne
+    @JoinColumn(name = "APPLICATION_FORM_ID", nullable = false)
+    private ApplicationFormEntity applicationForm;
+
+    @Column(name = "FIELD_ID")
+    private String fieldId;
+
+    @Column(name = "FIELD_VALUE", length = 255)
+    private String fieldValue;
+
+}
+

src/main/java/net/gepafin/tendermanagement/entities/BaseEntity.java

@@ -0,0 +1,35 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import net.gepafin.tendermanagement.util.DateTimeUtil;
+
+
+import java.time.LocalDateTime;
+
+@MappedSuperclass
+@Data
+public class BaseEntity {
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	@Column(name = "ID", unique = true)
+	private Long id;
+
+
+	@Column(name = "CREATED_DATE", updatable = false)
+    LocalDateTime createdDate;
+    
+    @Column(name = "UPDATED_DATE")
+    LocalDateTime updatedDate;
+    
+    @PrePersist
+	public void setCreatedDate() {
+		this.createdDate = DateTimeUtil.DateServerToUTC(LocalDateTime.now());
+		this.updatedDate = DateTimeUtil.DateServerToUTC(LocalDateTime.now());
+	}
+	@PreUpdate
+	public void setUpdatedDate() {
+		this.updatedDate = DateTimeUtil.DateServerToUTC(LocalDateTime.now());
+	}
+
+}

src/main/java/net/gepafin/tendermanagement/entities/CallEntity.java

@@ -0,0 +1,72 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "CALL")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class CallEntity extends BaseEntity {
+
+    @Column(name = "NAME", length = 255)
+    private String name;
+
+    @Column(name = "DESCRIPTION_SHORT", columnDefinition = "TEXT")
+    private String descriptionShort;
+
+    @Column(name = "DESCRIPTION_LONG", columnDefinition = "TEXT")
+    private String descriptionLong;
+
+    @Column(name = "START_DATE")
+    private LocalDateTime startDate;
+
+    @Column(name = "END_DATE")
+    private LocalDateTime endDate;
+
+    @Column(name = "STATUS", length = 255)
+    private String status;
+
+    @ManyToOne
+    @JoinColumn(name = "REGION_ID", foreignKey = @ForeignKey(name = "fk_region_call"))
+    private RegionEntity region;
+
+    @Column(name = "AMOUNT")
+    private BigDecimal amount;
+
+    @Column(name = "AMOUNT_MAX")
+    private BigDecimal amountMax;
+
+    @Column(name = "CONTACT_INFO", columnDefinition = "TEXT")
+    private String contactInfo;
+
+    @Column(name = "SUBMISSION_METHOD", columnDefinition = "TEXT")
+    private String submissionMethod;
+
+    @Column(name = "THRESHOLD")
+    private Long threshold;
+
+    @Column(name="DOCUMENTATION_REQUESTED",columnDefinition = "TEXT")
+    private String documentationRequested;
+
+    @Column(name = "PRIORITY_AREA", columnDefinition = "TEXT")
+    private String priorityArea;
+
+    @Column(name = "CONFIDI")
+    private Boolean confidi;
+
+    @Column(name="INITIAL_FORM")
+    private Long initialForm;
+
+    @Column(name="FINAL_FORM")
+    private Long finalForm;
+}
+

src/main/java/net/gepafin/tendermanagement/entities/CallTargetAudienceChecklistEntity.java

@@ -0,0 +1,26 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.Data;
+
+@Entity
+@Table(name = "CALL_TARGET_AUDIENCE_CHECKLIST")
+@Data
+public class CallTargetAudienceChecklistEntity extends BaseEntity{
+
+    @ManyToOne
+    @JoinColumn(name = "CALL_ID")
+    private CallEntity call;
+
+    @ManyToOne
+    @JoinColumn(name = "LOOKUP_DATA_ID")
+    private LookUpDataEntity lookupData;
+
+    @Column(name = "IS_VALIDATED")
+    private Boolean isValidated;
+    
+    @Column(name ="IS_DELETED", nullable = false)
+    private Boolean isDeleted = false;
+
+
+}

src/main/java/net/gepafin/tendermanagement/entities/DocumentEntity.java

@@ -0,0 +1,32 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.Data;
+
+@Entity
+@Table(name = "DOCUMENT")
+@Data
+public class DocumentEntity extends BaseEntity{
+    @Column(name = "FILE_NAME", length = 255)
+    private String fileName;
+
+    @Column(name = "FILE_PATH", length = 255)
+    private String filePath;
+
+    @Column(name="TYPE")
+    private String type;
+
+    @Column(name="SOURCE")
+    private String source;
+
+    @Column(name="SOURCE_ID")
+    private Long sourceId;
+
+    @Column(name ="IS_DELETED", nullable = false)
+    private Boolean isDeleted = false;
+
+}

src/main/java/net/gepafin/tendermanagement/entities/EvaluationCriteriaEntity.java

@@ -0,0 +1,29 @@
+package net.gepafin.tendermanagement.entities;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.Data;
+
+
+@Entity
+@Table(name = "EVALUATION_CRITERIA")
+@Data
+public class EvaluationCriteriaEntity extends BaseEntity {
+
+    @ManyToOne
+    @JoinColumn(name = "CALL_ID", nullable = false)
+    private CallEntity call;
+    
+    @ManyToOne
+    @JoinColumn(name = "LOOKUP_DATA_ID")
+    private LookUpDataEntity lookupData;
+    
+    @Column(name = "SCORE", nullable = false)
+    private Long score;
+    
+    @Column(name ="IS_DELETED", nullable = false)
+    private Boolean isDeleted = false;
+
+}

src/main/java/net/gepafin/tendermanagement/entities/FaqEntity.java

@@ -0,0 +1,46 @@
+package net.gepafin.tendermanagement.entities;
+
+import java.time.LocalDateTime;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.ForeignKey;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.Data;
+
+
+@Entity
+@Table(name = "FAQ")
+@Data
+public class FaqEntity extends BaseEntity {
+
+    @ManyToOne
+    @JoinColumn(name = "CALL_ID", nullable = false)
+    private CallEntity call;
+
+    @ManyToOne
+    @JoinColumn(name = "USER_ID", nullable = false, foreignKey = @ForeignKey(name = "fk_user_faq"))
+    private UserEntity user;
+
+    @Column(name = "IS_VISIBLE", nullable = false)
+    private Boolean isVisible;
+
+    @Column(name = "TITLE", columnDefinition = "TEXT")
+    private String title;
+    
+    @Column(name = "VALUE", columnDefinition = "TEXT")
+    private String value;
+
+    @Column(name = "RESPONSE", columnDefinition = "TEXT")
+    private String response;
+
+    @Column(name = "RESPONSE_DATE")
+    private LocalDateTime responseDate;
+    
+    @Column(name ="IS_DELETED", nullable = false)
+    private Boolean isDeleted = false;
+
+}
+

src/main/java/net/gepafin/tendermanagement/entities/FlowDataEntity.java

@@ -0,0 +1,26 @@
+package net.gepafin.tendermanagement.entities;
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "FLOW_DATA")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class FlowDataEntity extends BaseEntity{
+
+    @Column(name = "FORM_ID")
+    private Long formId;
+
+    @Column(name = "CHOOSEN_FIELD")
+    private String choosenField;
+
+    @Column(name = "CHOOSEN_VALUE")
+    private String choosenValue;
+
+    @Column(name="CALL_ID")
+    private Long callId;
+}

src/main/java/net/gepafin/tendermanagement/entities/FlowEdgesEntity.java

@@ -0,0 +1,31 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "FLOW_EDGES")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class FlowEdgesEntity extends BaseEntity {
+
+    @Column(name = "SOURCE_ID")
+    private Long sourceId;
+
+    @Column(name = "TARGET_ID")
+    private Long targetId;
+
+    @Column(name = "TYPE", length = 255)
+    private String type;
+
+    @Column(name="CALL_ID")
+    private Long callId;
+
+    @Column(name="TRACKING_ID")
+    private String trackingId;
+
+}

src/main/java/net/gepafin/tendermanagement/entities/FormEntity.java

@@ -0,0 +1,26 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Builder;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "FORM")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class FormEntity extends BaseEntity{
+    
+    @Column(name = "LABEL", length = 255)
+    private String label;
+
+    @ManyToOne
+    @JoinColumn(name = "CALL_ID", foreignKey = @ForeignKey(name = "fk_call_form"))
+    private CallEntity call;
+
+    @Column(name = "CONTENT", length = 255)
+    private String content;
+}

src/main/java/net/gepafin/tendermanagement/entities/FormFieldEntity.java

@@ -0,0 +1,34 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Builder;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "FORM_FIELD")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class FormFieldEntity extends BaseEntity{
+
+    @Column(name = "NAME", length = 255)
+    private String name;
+
+    @Column(name = "LABEL", length = 255)
+    private String label;
+
+    @Column(name = "SETTINGS")
+    private String settings;
+
+    @Column(name = "VALIDATORS")
+    private String validators;
+
+    @Column(name = "DESCRIPTION")
+    private String description;
+
+    @Column(name = "SORT_ORDER")
+    private Integer sortOrder;
+}

src/main/java/net/gepafin/tendermanagement/entities/FormTemplateEntity.java

@@ -0,0 +1,22 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Builder;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "FORM_TEMPLATE")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class FormTemplateEntity extends BaseEntity{
+
+    @Column(name = "LABEL", length = 255)
+    private String label;
+
+    @Column(name = "CONTENT", length = 255)
+    private String content;
+}

src/main/java/net/gepafin/tendermanagement/entities/LookUpDataEntity.java

@@ -0,0 +1,41 @@
+package net.gepafin.tendermanagement.entities;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+import jakarta.persistence.*;
+import lombok.Data;
+
+@Entity
+@Table(name = "LOOKUP_DATA")
+@Data
+public class LookUpDataEntity extends BaseEntity{
+
+    @Column(name = "TITLE", columnDefinition = "TEXT", nullable = true)
+    private String title;
+
+    @Column(name = "TYPE", length = 255, nullable = false)
+    private String type;
+
+    @Column(name = "VALUE", columnDefinition = "TEXT", nullable = true)
+    private String value;
+    
+    @Column(name = "RESPONSE", columnDefinition = "TEXT")
+    private String response;
+
+    public enum LookUpDataTypeEnum {
+        CHECKLIST("CHECKLIST"),
+        AIMED_TO("AIMED_TO"),
+        EVALUATION_CRITERIA("EVALUATION_CRITERIA"),
+        FAQ("FAQ");
+
+        private String value;
+
+        LookUpDataTypeEnum(String value) {
+            this.value = value;
+        }
+
+        @JsonValue
+        public String getValue() {
+            return value;
+        }
+    }
+}

src/main/java/net/gepafin/tendermanagement/entities/RegionEntity.java

@@ -0,0 +1,56 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+
+@Entity
+@Table(name = "REGION")
+@Getter
+@Setter
+public class RegionEntity extends BaseEntity {
+
+    @Column(name = "REGION_NAME", length = 255, nullable = true)
+    private String regionName;
+
+    @Column(name = "DESCRIPTION", length = 255, nullable = true)
+    private String description;
+
+    @Column(name = "COUNTRY", length = 50, nullable = true)
+    private String country;
+
+    @Column(name = "STATUS", length = 30, nullable = true)
+    private String status;
+
+    @Column(name = "PRIORITY_AREA", length = 255, nullable = true)
+    private String priorityArea;
+
+    @Column(name = "POPULATION", nullable = true)
+    private Long population;
+
+    @Column(name = "AREA_SIZE", nullable = true)
+    private BigDecimal areaSize;
+
+    @Column(name = "GDP", nullable = true)
+    private BigDecimal gdp;
+
+    @Column(name = "UNEMPLOYMENT_RATE", nullable = true)
+    private BigDecimal unemploymentRate;
+
+    @Column(name = "INFRASTRUCTURE_SCORE", nullable = true)
+    private BigDecimal infrastructureScore;
+
+    @Column(name = "EDUCATION_LEVEL", nullable = true)
+    private BigDecimal educationLevel;
+
+    @Column(name = "HEALTHCARE_ACCESS", nullable = true)
+    private BigDecimal healthcareAccess;
+
+    @Column(name = "ENVIRONMENTAL_SCORE", nullable = true)
+    private BigDecimal environmentalScore;
+}

src/main/java/net/gepafin/tendermanagement/entities/RoleEntity.java

@@ -0,0 +1,30 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "ROLE")
+@Getter
+@Setter
+public class RoleEntity extends BaseEntity {
+
+    @Column(name = "ROLE_NAME", length = 255, nullable = true)
+    private String roleName;
+
+    @Column(name = "DESCRIPTION", length = 255, nullable = true)
+    private String description;
+
+    @Column(name = "PERMISSIONS", length = 255, nullable = true)
+    private String permissions;
+    
+    @ManyToOne
+    @JoinColumn(name = "REGION_ID", nullable = true)
+    private RegionEntity region;
+    
+    @Column(name = "ROLE_TYPE", length = 255, nullable = true)
+    private String roleType;
+
+}

src/main/java/net/gepafin/tendermanagement/entities/SamlResponseEntity.java

@@ -0,0 +1,20 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.Data;
+
+@Entity
+@Table(name = "SAML_RESPONSE")
+@Data
+public class SamlResponseEntity extends BaseEntity{
+	
+	@Column(name = "AUTHENTICATION_OBJECT")
+	private String authenticationObject;
+	
+	@Column(name = "TOKEN")
+	private String token;
+	
+
+}

src/main/java/net/gepafin/tendermanagement/entities/UserEntity.java

@@ -0,0 +1,67 @@
+package net.gepafin.tendermanagement.entities;
+
+import jakarta.persistence.*;
+import jakarta.validation.constraints.Email;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "GEPAFIN_USER")
+@Getter
+@Setter
+public class UserEntity extends BaseEntity {
+
+    @Column(name = "PASSWORD", columnDefinition = "TEXT",nullable = true)
+    @JsonIgnore
+    private String password;
+
+    @Email
+    @Column(name = "EMAIL", length = 255, unique = true, nullable = false)
+    private String email;
+
+    @ManyToOne
+    @JoinColumn(name = "ROLE_ID")
+    @JsonIgnore
+    private RoleEntity roleEntity;
+    
+    @Column(name = "LAST_LOGIN")
+    private LocalDateTime lastLogin;
+
+    @Column(name = "STATUS", length = 30, nullable = true)
+    private String status;
+
+    @Column(name = "FIRST_NAME", length = 50, nullable = true)
+    private String firstName;
+
+    @Column(name = "LAST_NAME", length = 50, nullable = true)
+    private String lastName;
+
+    @Column(name = "PHONE_NUMBER", length = 15, nullable = true)
+    private String phoneNumber;
+
+    @Column(name = "ORGANIZATION", length = 255, nullable = true)
+    private String organization;
+
+    @Column(name = "ADDRESS", length = 255, nullable = true)
+    private String address;
+
+    @Column(name = "CITY", length = 50, nullable = true)
+    private String city;
+
+    @Column(name = "COUNTRY", length = 50, nullable = true)
+    private String country;
+
+    @Column(name = "RESET_PASSWORD_TOKEN", length = 255, nullable = true)
+    private String resetPasswordToken;
+    
+    @Column(name = "CODICE_FISCALE")
+    private String codiceFiscale;
+    
+    @Column(name = "DATE_OF_BIRTH")
+    private LocalDateTime dateOfBirth;
+}

src/main/java/net/gepafin/tendermanagement/enums/ApplicationStatusTypeEnum.java

@@ -0,0 +1,21 @@
+package net.gepafin.tendermanagement.enums;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum ApplicationStatusTypeEnum {
+
+    DRAFT("DRAFT"),
+    SUBMIT("SUBMIT"),
+    DISCARD("DISCARD");
+
+    private String value;
+
+    ApplicationStatusTypeEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/net/gepafin/tendermanagement/enums/CallStatusEnum.java

@@ -0,0 +1,42 @@
+package net.gepafin.tendermanagement.enums;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public enum CallStatusEnum {
+
+        DRAFT("DRAFT"),
+        PUBLISH("PUBLISH"),
+        EXPIRED("EXPIRED"),
+        READY_TO_PUBLISH("READY_TO_PUBLISH");
+
+        private String value;
+
+      CallStatusEnum(String value) {
+            this.value = value;
+        }
+
+        @JsonValue
+        public String getValue() {
+            return value;
+        }
+
+    @JsonCreator
+    public static CallStatusEnum fromValue(String value) {
+        for (CallStatusEnum b : CallStatusEnum.values()) {
+            if (b.value.equals(value)) {
+                return b;
+            }
+        }
+        throw new IllegalArgumentException("Unexpected value '" + value + "'");
+    }
+    public static List<String> getStatusValues() {
+        return Arrays.stream(CallStatusEnum.values())
+                .map(CallStatusEnum::getValue)
+                .collect(Collectors.toList());
+    }
+}

src/main/java/net/gepafin/tendermanagement/enums/DocumentSourceTypeEnum.java

@@ -0,0 +1,17 @@
+package net.gepafin.tendermanagement.enums;
+
+public enum DocumentSourceTypeEnum {
+    CALL("CALL"),
+
+    APPLICATION("APPLICATION");
+
+    private String value;
+
+    DocumentSourceTypeEnum(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/net/gepafin/tendermanagement/enums/DocumentTypeEnum.java

@@ -0,0 +1,20 @@
+package net.gepafin.tendermanagement.enums;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum DocumentTypeEnum {
+
+    DOCUMENT("DOCUMENT"),
+    IMAGES("IMAGES");
+
+    private String value;
+
+    DocumentTypeEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/net/gepafin/tendermanagement/enums/FormActionEnum.java

@@ -0,0 +1,20 @@
+package net.gepafin.tendermanagement.enums;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum FormActionEnum {
+
+    NEXT("NEXT"),
+    PREVIOUS("PREVIOUS");
+
+    private String value;
+
+    FormActionEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/net/gepafin/tendermanagement/enums/RegionStatusEnum.java

@@ -0,0 +1,18 @@
+package net.gepafin.tendermanagement.enums;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum RegionStatusEnum {
+    ACTIVE("ACTIVE"),
+    INACTIVE("INACTIVE");
+
+    private String value;
+
+    RegionStatusEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/net/gepafin/tendermanagement/enums/RoleStatusEnum.java

@@ -0,0 +1,22 @@
+package net.gepafin.tendermanagement.enums;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum RoleStatusEnum {
+
+	ROLE_BENEFICIARY("ROLE_BENEFICIARY"),
+	ROLE_SUPER_ADMIN("ROLE_SUPER_ADMIN"),
+	ROLE_PRE_INSTRUCTOR("ROLE_PRE_INSTRUCTOR"),
+	ROLE_GEPAFIN_OPERATOR("ROLE_GEPAFIN_OPERATOR");
+
+    private String value;
+
+    RoleStatusEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/net/gepafin/tendermanagement/enums/UserStatusEnum.java

@@ -0,0 +1,21 @@
+package net.gepafin.tendermanagement.enums;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum UserStatusEnum {
+    ACTIVE("ACTIVE"),
+    INACTIVE("INACTIVE"),
+
+    PENDING_VERIFICATION("PENDING_VERIFICATION");
+
+    private String value;
+
+    UserStatusEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/net/gepafin/tendermanagement/model/BaseBean.java

@@ -0,0 +1,16 @@
+package net.gepafin.tendermanagement.model;
+
+import java.time.LocalDateTime;
+
+import lombok.Data;
+
+@Data
+public class BaseBean {
+
+    private Long id;
+
+    private LocalDateTime createdDate;
+
+    private LocalDateTime updatedDate;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/ApplicationFormFieldRequestBean.java

@@ -0,0 +1,14 @@
+package net.gepafin.tendermanagement.model.request;
+
+import jakarta.persistence.Column;
+import lombok.Data;
+import net.gepafin.tendermanagement.entities.ApplicationFormEntity;
+
+@Data
+public class ApplicationFormFieldRequestBean  {
+    
+    private String fieldId;
+
+    private String fieldValue;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/ApplicationRequest.java

@@ -0,0 +1,12 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+public class ApplicationRequest {
+
+    private String comments;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/ApplicationRequestBean.java

@@ -0,0 +1,13 @@
+package net.gepafin.tendermanagement.model.request;
+
+import jakarta.persistence.Column;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+public class ApplicationRequestBean {
+
+    private List<ApplicationFormFieldRequestBean> formFields;
+}

src/main/java/net/gepafin/tendermanagement/model/request/ChangePasswordRequest.java

@@ -0,0 +1,16 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class ChangePasswordRequest {
+
+
+    private String email;
+
+    private String password;
+
+    private String newPassword;
+
+    private String confirmPassword;
+}

src/main/java/net/gepafin/tendermanagement/model/request/ContentRequestBean.java

@@ -0,0 +1,18 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class ContentRequestBean {
+
+    private String id;
+    private String name;
+    private String label;
+    private List<SettingRequestBean> settings;
+    private Map<String,Object> validators;
+    private Integer dbId;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/CreateCallRequestStep1.java

@@ -0,0 +1,33 @@
+package net.gepafin.tendermanagement.model.request;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class CreateCallRequestStep1 {
+
+    private String name;
+
+    private String descriptionShort;
+
+    private String descriptionLong;
+
+    private List<LocalDateTime> dates;
+
+    private Long regionId;
+
+    private BigDecimal amount;
+
+    private BigDecimal amountMax;
+
+    private List<LookUpDataReq> aimedTo;
+
+    private String documentationRequested;
+
+    private Boolean confidi;
+
+    private List<FaqReq> faq;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/CreateCallRequestStep2.java

@@ -0,0 +1,20 @@
+package net.gepafin.tendermanagement.model.request;
+
+import java.util.List;
+
+import lombok.Data;
+
+@Data
+public class CreateCallRequestStep2 {
+
+    private Long threshold;
+
+    private List<EvaluationCriteriaReq> criteria;
+
+    private List<LookUpDataReq> checkList;
+
+    private List<DocumentReq> docs;
+
+    private List<DocumentReq> images;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/DocumentReq.java

@@ -0,0 +1,11 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class DocumentReq {
+
+    private Long id;
+    private String url;
+    private String fileName;
+}

src/main/java/net/gepafin/tendermanagement/model/request/EvaluationCriteriaReq.java

@@ -0,0 +1,11 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+@Data
+public class EvaluationCriteriaReq extends LookUpDataReq{
+
+    private Long score;
+}

src/main/java/net/gepafin/tendermanagement/model/request/EvaluationCriteriaRequest.java

@@ -0,0 +1,13 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+@Data
+public class EvaluationCriteriaRequest extends LookUpDataReq {
+
+    private Long callId;
+
+    private Long score;
+}

src/main/java/net/gepafin/tendermanagement/model/request/FaqReq.java

@@ -0,0 +1,10 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class FaqReq extends LookUpDataReq {
+
+	private Boolean isVisible;
+	private String response;
+}

src/main/java/net/gepafin/tendermanagement/model/request/FieldValidatorBean.java

@@ -0,0 +1,18 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class FieldValidatorBean {
+
+    private Boolean isRequired;
+
+    private Long minLength;
+
+    private Long maxLength;
+
+    private String pattern;
+
+    private String custom;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/FlowDataRequestBean.java

@@ -0,0 +1,13 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class FlowDataRequestBean {
+
+    private Long formId;
+
+    private String chosenField;
+
+    private String chosenValue;
+}

src/main/java/net/gepafin/tendermanagement/model/request/FlowEdgesRequestBean.java

@@ -0,0 +1,15 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class FlowEdgesRequestBean {
+
+    private String id;
+
+    private String source;
+
+    private String target;
+
+    private String type;
+}

src/main/java/net/gepafin/tendermanagement/model/request/FlowRequestBean.java

@@ -0,0 +1,17 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class FlowRequestBean {
+
+    private Long initialForm;
+
+    private Long finalForm;
+
+    private List<FlowDataRequestBean> flowData;
+
+    private List<FlowEdgesRequestBean> flowEdges;
+}

src/main/java/net/gepafin/tendermanagement/model/request/FormFieldRequest.java

@@ -0,0 +1,22 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class FormFieldRequest {
+
+    private String name;
+
+    private String description;
+
+    private Integer sortOrder;
+
+    private String label;
+
+    private List<SettingRequestBean> settings;
+
+    private Map<String,Object> validators;
+}

src/main/java/net/gepafin/tendermanagement/model/request/FormRequest.java

@@ -0,0 +1,14 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class FormRequest {
+
+    private String label;
+
+    private List<ContentRequestBean> content;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/FormTemplateRequest.java

@@ -0,0 +1,13 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class FormTemplateRequest {
+
+    private String label;
+
+    private List<ContentRequestBean> content;
+}

src/main/java/net/gepafin/tendermanagement/model/request/InitiatePasswordResetReq.java

@@ -0,0 +1,8 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class InitiatePasswordResetReq {
+    private String email;
+}

src/main/java/net/gepafin/tendermanagement/model/request/LoginReq.java

@@ -0,0 +1,18 @@
+package net.gepafin.tendermanagement.model.request;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class LoginReq {
+    @NotBlank(message = "{email.not.blank}")
+    @Email(message = "{email.invalid}")
+    private String email;
+    @NotEmpty
+    private String password;
+    private  Boolean rememberMe;
+}

src/main/java/net/gepafin/tendermanagement/model/request/LogoutReq.java

@@ -0,0 +1,8 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class LogoutReq {
+    private String email;
+}

src/main/java/net/gepafin/tendermanagement/model/request/LookUpDataReq.java

@@ -0,0 +1,17 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class LookUpDataReq {
+
+	private Long id;
+	
+    private Long lookUpDataId;
+    
+    private String title;
+
+    private String value;
+    
+    private String response;
+}

src/main/java/net/gepafin/tendermanagement/model/request/LookUpDataRequest.java

@@ -0,0 +1,13 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum;
+
+@Data
+public class LookUpDataRequest {
+
+    private String title;
+    private LookUpDataTypeEnum type;
+    private String value;
+    private String response;
+}

src/main/java/net/gepafin/tendermanagement/model/request/RegionReq.java

@@ -0,0 +1,36 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+import net.gepafin.tendermanagement.enums.RegionStatusEnum;
+
+import java.math.BigDecimal;
+
+@Data
+public class RegionReq {
+
+    private String regionName;
+
+    private String description;
+
+    private String country;
+
+    private RegionStatusEnum status;
+
+    private String priorityArea;
+
+    private Long population;
+
+    private BigDecimal areaSize;
+
+    private BigDecimal gdp;
+
+    private BigDecimal unemploymentRate;
+
+    private BigDecimal infrastructureScore;
+
+    private BigDecimal educationLevel;
+
+    private BigDecimal healthcareAccess;
+
+    private BigDecimal environmentalScore;
+}

src/main/java/net/gepafin/tendermanagement/model/request/ResetPasswordReq.java

@@ -0,0 +1,13 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class ResetPasswordReq {
+    private String email;
+    private String token;
+    private String newPassword;
+    private String confirmPassword;
+
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/RoleReq.java

@@ -0,0 +1,27 @@
+package net.gepafin.tendermanagement.model.request;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+public class RoleReq {
+
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    private Long id;
+
+    private String roleName;
+
+    private String description;
+
+    private List<String> permissions;
+
+    private Long regionId;
+    
+    private String roleType;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/SettingRequestBean.java

@@ -0,0 +1,11 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Data;
+
+@Data
+public class SettingRequestBean {
+
+    private String name;
+
+    private Object value;
+}

src/main/java/net/gepafin/tendermanagement/model/request/UpdateCallRequestStep1.java

@@ -0,0 +1,32 @@
+package net.gepafin.tendermanagement.model.request;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+
+import lombok.Data;
+
+@Data
+public class UpdateCallRequestStep1 {
+
+	private String name;
+
+	private String descriptionShort;
+
+	private String descriptionLong;
+
+	private List<LocalDateTime> dates;
+
+	private BigDecimal amount;
+
+	private BigDecimal amountMax;
+
+	private List<LookUpDataReq> aimedTo;
+
+	private String documentationRequested;
+
+	private Boolean confidi;
+
+	private List<FaqReq> faq;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/UpdateRegionReq.java

@@ -0,0 +1,36 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Getter;
+import lombok.Setter;
+import net.gepafin.tendermanagement.enums.RegionStatusEnum;
+
+@Getter
+@Setter
+public class UpdateRegionReq {
+    private String regionName;
+
+    private String description;
+
+    private String country;
+
+    private RegionStatusEnum status;
+
+    private String priorityArea;
+
+    private Long population;
+
+    private Double areaSize;
+
+    private Double gdp;
+
+    private Double unemploymentRate;
+
+    private Double infrastructureScore;
+
+    private Double educationLevel;
+
+    private Double healthcareAccess;
+
+    private Double environmentalScore;
+
+}

src/main/java/net/gepafin/tendermanagement/model/request/UpdateUserReq.java

@@ -0,0 +1,20 @@
+package net.gepafin.tendermanagement.model.request;
+
+import lombok.Getter;
+import lombok.Setter;
+import net.gepafin.tendermanagement.enums.UserStatusEnum;
+
+@Getter
+@Setter
+public class UpdateUserReq  {
+
+    private String firstName;
+    private String lastName;
+    private String phoneNumber;
+    private Long roleId;
+    private String organization;
+    private String address;
+    private String city;
+    private UserStatusEnum status;
+    private String country;
+}

src/main/java/net/gepafin/tendermanagement/model/request/UserReq.java

@@ -0,0 +1,35 @@
+package net.gepafin.tendermanagement.model.request;
+
+import java.time.LocalDateTime;
+import lombok.Data;
+
+@Data
+public class UserReq {
+
+    private String email;
+    
+    private String password;
+    
+    private String confPassword;
+
+    private String firstName;
+
+    private String lastName;
+
+    private String phoneNumber;
+    
+    private Long roleId;
+
+    private String organization;
+
+    private String address;
+
+    private String city;
+
+    private String country;
+    
+    private String codiceFiscale;
+    
+    private LocalDateTime dateOfBirth;
+
+}

src/main/java/net/gepafin/tendermanagement/model/response/ApplicationFormFieldResponseBean.java

@@ -0,0 +1,16 @@
+package net.gepafin.tendermanagement.model.response;
+
+import lombok.Data;
+import net.gepafin.tendermanagement.model.BaseBean;
+
+@Data
+public class ApplicationFormFieldResponseBean extends BaseBean {
+
+    private Long id;
+
+    private Long applicationFormId;
+
+    private String fieldId;
+
+    private Object fieldValue;
+}

src/main/java/net/gepafin/tendermanagement/model/response/ApplicationGetResponseBean.java

@@ -0,0 +1,25 @@
+package net.gepafin.tendermanagement.model.response;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+public class ApplicationGetResponseBean {
+
+    private Long id;
+
+    private LocalDateTime submissionDate;
+
+    private String status;
+
+    private String comments;
+    
+    private Long callId;
+    
+    private String callTitle;
+
+    private List<FormApplicationResponse> form;
+
+}

src/main/java/net/gepafin/tendermanagement/model/response/ApplicationResponse.java

@@ -0,0 +1,30 @@
+package net.gepafin.tendermanagement.model.response;
+
+import lombok.Data;
+import net.gepafin.tendermanagement.model.response.ApplicationFormFieldResponseBean;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+public class ApplicationResponse{
+
+    private Long id;
+
+    private Long callId;
+
+    private String callTitle;
+
+    private LocalDateTime callEndDate;
+
+    private LocalDateTime modifiedDate;
+
+    private Integer progress;
+
+    private LocalDateTime submissionDate;
+
+    private String status;
+
+    private String comments;
+
+}

src/main/java/net/gepafin/tendermanagement/model/response/ApplicationResponseBean.java

@@ -0,0 +1,22 @@
+package net.gepafin.tendermanagement.model.response;
+
+import lombok.Data;
+import net.gepafin.tendermanagement.model.BaseBean;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+public class ApplicationResponseBean extends BaseBean {
+
+    private Long callId;
+
+    private LocalDateTime submissionDate;
+
+    private String status;
+
+    private String comments;
+
+    private List<ApplicationFormFieldResponseBean> formFields;
+
+}