diff --git a/.gitignore b/.gitignore index 524f0963..219512a8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,24 +1,42 @@ -# Compiled class file -*.class +HELP.md +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* diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 00000000..26d33521 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..ceacf16e --- /dev/null +++ b/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"] diff --git a/Jenkinsfile b/Jenkinsfile new file mode 100644 index 00000000..d488b39e --- /dev/null +++ b/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"' + } + } + } + } +} \ No newline at end of file diff --git a/README.md b/README.md index d48d3162..c79beeee 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,3 @@ # GEPAFIN-BE Back Gepafin Project +Please add doc here diff --git a/mvnw b/mvnw new file mode 100644 index 00000000..d7c358e5 --- /dev/null +++ b/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-,maven-mvnd--}/ +[ -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 "$@" diff --git a/mvnw.cmd b/mvnw.cmd new file mode 100644 index 00000000..6f779cff --- /dev/null +++ b/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-,maven-mvnd--}/ +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" diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..a2a1e712 --- /dev/null +++ b/pom.xml @@ -0,0 +1,207 @@ + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.3.2 + + + net.gepafin + tendermanagement + 0.0.1-SNAPSHOT + tendermanagement + Tender Management project + + 17 + 1.5.5.Final + + + + + org.springframework.boot + spring-boot-starter-web + + + + + org.projectlombok + lombok + + + + + com.h2database + h2 + + + + + org.postgresql + postgresql + + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + + + org.springdoc + springdoc-openapi-starter-webmvc-ui + 2.2.0 + + + + + org.mapstruct + mapstruct + ${mapstruct.version} + + + org.mapstruct + mapstruct-processor + ${mapstruct.version} + provided + + + + org.liquibase + liquibase-core + + + + + org.springframework.boot + spring-boot-starter-test + test + + + + com.amazonaws + aws-java-sdk-s3 + 1.12.312 + + + + com.amazonaws + aws-java-sdk-core + 1.12.341 + + + + commons-io + commons-io + 2.11.0 + + + + org.springframework.boot + spring-boot-starter-security + + + io.jsonwebtoken + jjwt-api + 0.11.5 + + + io.jsonwebtoken + jjwt-impl + 0.11.5 + + + io.jsonwebtoken + jjwt-jackson + 0.11.5 + + + jakarta.validation + jakarta.validation-api + + + org.hibernate.validator + hibernate-validator + + + + com.google.code.gson + gson + + + + org.zalando + problem-spring-web + 0.23.0 + + + + + org.springframework.security + spring-security-saml2-service-provider + + + + + org.opensaml + opensaml-core + 4.2.0 + + + + + + org.opensaml + opensaml-saml-api + 4.2.0 + + + + + + org.opensaml + opensaml-saml-impl + 4.2.0 + + + + + + org.springframework.cloud + spring-cloud-starter-openfeign + 4.1.3 + + + + org.apache.santuario + xmlsec + 2.3.0 + + + + + + + shibboleth + https://build.shibboleth.net/nexus/content/repositories/releases/ + + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + org.liquibase + liquibase-maven-plugin + + src/main/resources/application.properties + + + + + diff --git a/src/main/java/net/gepafin/tendermanagement/TendermanagementApplication.java b/src/main/java/net/gepafin/tendermanagement/TendermanagementApplication.java new file mode 100644 index 00000000..7ec98464 --- /dev/null +++ b/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); + } + } + +} + diff --git a/src/main/java/net/gepafin/tendermanagement/config/AmazonConfig.java b/src/main/java/net/gepafin/tendermanagement/config/AmazonConfig.java new file mode 100644 index 00000000..878cd12f --- /dev/null +++ b/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(); + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/config/MessageSourceConfig.java b/src/main/java/net/gepafin/tendermanagement/config/MessageSourceConfig.java new file mode 100644 index 00000000..6f9767c6 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/config/SamlConfig.java b/src/main/java/net/gepafin/tendermanagement/config/SamlConfig.java new file mode 100644 index 00000000..02a0ae27 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/config/SamlFailureHandler.java b/src/main/java/net/gepafin/tendermanagement/config/SamlFailureHandler.java new file mode 100644 index 00000000..81df79e3 --- /dev/null +++ b/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); + } + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/config/SamlRequestLogger.java b/src/main/java/net/gepafin/tendermanagement/config/SamlRequestLogger.java new file mode 100644 index 00000000..fd4d6561 --- /dev/null +++ b/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"; + } + } +} + diff --git a/src/main/java/net/gepafin/tendermanagement/config/SamlSuccessHandler.java b/src/main/java/net/gepafin/tendermanagement/config/SamlSuccessHandler.java new file mode 100644 index 00000000..a8af08a7 --- /dev/null +++ b/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> 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> 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); + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/config/SchemaInit.java b/src/main/java/net/gepafin/tendermanagement/config/SchemaInit.java new file mode 100644 index 00000000..6d57f81f --- /dev/null +++ b/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); + } + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/config/SecurityConfig.java b/src/main/java/net/gepafin/tendermanagement/config/SecurityConfig.java new file mode 100644 index 00000000..91424195 --- /dev/null +++ b/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"))); + } + + +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/config/Translator.java b/src/main/java/net/gepafin/tendermanagement/config/Translator.java new file mode 100644 index 00000000..35ad8227 --- /dev/null +++ b/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()); + } + +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/config/jwt/JWTConfigurer.java b/src/main/java/net/gepafin/tendermanagement/config/jwt/JWTConfigurer.java new file mode 100644 index 00000000..1ee7efe6 --- /dev/null +++ b/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 { + + 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); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/config/jwt/JWTFilter.java b/src/main/java/net/gepafin/tendermanagement/config/jwt/JWTFilter.java new file mode 100644 index 00000000..4d8d5948 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/config/jwt/TokenProvider.java b/src/main/java/net/gepafin/tendermanagement/config/jwt/TokenProvider.java new file mode 100644 index 00000000..d299b6ff --- /dev/null +++ b/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 invalidatedTokens = new HashSet<>(); + private static final String USER_ID = "userId"; + + public UserEntity validateUser(Map 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 ClaimsToAuthorities(Object authClaim) { + Collection 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 getUserInfoAndUserIdFromToken(HttpServletRequest request) { + Map 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 extractDetailsFromTheToken(Map userInfo, String authSecretHeader, + String token) { + String payload = null; + Boolean isSuperAdmin = false; +// if (StringUtils.hasText(token) && token.endsWith("_superKey" + getSuperUserToken())) { +// Map 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 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 + } + +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/constants/GepafinConstant.java b/src/main/java/net/gepafin/tendermanagement/constants/GepafinConstant.java new file mode 100644 index 00000000..d79edb37 --- /dev/null +++ b/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"; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/ApplicationDao.java b/src/main/java/net/gepafin/tendermanagement/dao/ApplicationDao.java new file mode 100644 index 00000000..e520a6ef --- /dev/null +++ b/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 applicationFormFieldResponseBeans=new ArrayList<>(); + ApplicationFormFieldResponseBean applicationFormFieldResponseBeans1=null; + List applicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId()); + applicationFormFieldResponseBeans=createApplicationFormFieldResponse(applicationFormFieldEntities, applicationFormEntity, applicationFormFieldResponseBeans); + ApplicationResponseBean applicationResponseBean= convertApplicationEntityToApplicationResponseBean(applicationEntity); + applicationResponseBean.setFormFields(applicationFormFieldResponseBeans); + return applicationResponseBean; + } + + private List createApplicationFormFieldResponse( + List applicationFormFieldEntities, + ApplicationFormEntity applicationFormEntity, + List applicationFormFieldResponseBeans) { + + List contentResponseBeans = Utils.convertJsonStringToList( + applicationFormEntity.getForm().getContent(), ContentResponseBean.class); + + for (ApplicationFormFieldEntity applicationFormFieldEntity : applicationFormFieldEntities) { + + Optional fileUploadContent = contentResponseBeans.stream() + .filter(contentResponseBean -> "fileupload".equals(contentResponseBean.getName()) && + contentResponseBean.getId().equals(applicationFormFieldEntity.getFieldId())) + .findFirst(); + + List 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 getAllApplications(UserEntity userEntity, Long callId) { + boolean isBeneficiary = isBeneficiary(userEntity); + + log.info("Fetching applications for RoleType: {}", userEntity.getRoleEntity().getRoleType()); + List 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 applicationEntities = isBeneficiary + ? applicationRepository.findByUserIdAndCallIdAndIsDeletedFalse(userEntity.getId(), call.getId()) + .map(List::of) // Convert Optional 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 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 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 createOrUpdateMultipleFormFields(List formFieldResponseBeans, ApplicationFormEntity applicationFormEntity,FormEntity formEntity) { + List existingFields = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId()); + + List applicationFormFieldEntity = formFieldResponseBeans.stream() + .map(requestBean -> createOrUpdateApplicationFormField(requestBean, applicationFormEntity,existingFields,formEntity)) + .collect(Collectors.toList()); + return applicationFormFieldEntity; + } + + public ApplicationFormFieldEntity createOrUpdateApplicationFormField(ApplicationFormFieldRequestBean applicationFormFieldRequestBean, ApplicationFormEntity applicationFormEntity,List 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 validateFileUploadDocuments(ApplicationFormFieldRequestBean applicationFormFieldRequestBean, FormEntity formEntity) { + List documentIds=null; + List 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 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 = 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 saveApplicationFormFieldEntities(List applicationFormFieldEntities) { + List applicationFormFieldEntities1 = applicationFormFieldRepository.saveAll(applicationFormFieldEntities); + return applicationFormFieldEntities1; + } + + public List convertApplicationFormFieldEntitiesToApplicationFormFieldResponseBeans(List 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 formApplicationResponses = new ArrayList<>(); + List 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 application = applicationRepository.findByUserIdAndCallIdAndIsDeletedFalse(userEntity.getId(), + formEntity.getCall().getId()); + applicationEntity=application.get(); + formEntities.add(formEntity); + addFormApplication(formEntity, applicationEntity, formApplicationResponses); + } + else { + List 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 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 applicationFormFieldResponseBeans =new ArrayList<>(); + ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), formEntity.getId()); + if(applicationFormEntity!=null) { + List applicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId()); +// formApplicationResponse = createFormApplicationResponse(formEntity); + applicationFormFieldResponseBeans = createApplicationFormFieldResponse(applicationFormFieldEntities, applicationFormEntity,applicationFormFieldResponseBeans); + formApplicationResponse.setFormFields(applicationFormFieldResponseBeans); + } + return formApplicationResponse; + } + + private ApplicationGetResponseBean createApplicationGetResponseBean(ApplicationEntity applicationEntity, List formEntities, List 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=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 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 errors=new ArrayList<>(); + List contentResponseBeans=Utils.convertJsonStringToList(formEntity.getContent(),ContentResponseBean.class); + + List requestFields = request.getFormFields(); + + Map 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 nextFormIds = flowEdgesRepository.findBySourceIdAndCallId( + formEntity.getId(), applicationEntity.getCall().getId()) + .stream() + .map(FlowEdgesEntity::getTargetId) + .collect(Collectors.toList()); + + Optional 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 nextApplicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(nextApplicationFormEntity.getId()); + applicationFormFieldRepository.deleteAll(nextApplicationFormFieldEntities); + applicationFormRepository.delete(nextApplicationFormEntity); + } + } + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/CallDao.java b/src/main/java/net/gepafin/tendermanagement/dao/CallDao.java new file mode 100644 index 00000000..1b3f60d0 --- /dev/null +++ b/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 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 convertToEvaluationCriteriaEntities( + List criteriaReqList, CallEntity callEntity, LookUpDataTypeEnum type) { + if (criteriaReqList == null) { + return null; + } + List existingCriteria = evaluationCriteriaRepository.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), type.getValue()); + + List 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 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 convertToDocumentEntities(List documentReqList, Long sourceId, + DocumentTypeEnum documentType) { + if (documentReqList == null) { + return null; + } + + List existingDocuments = documentRepository + .findBySourceIdAndTypeAndIsDeletedFalse(sourceId, documentType.getValue()); + + List 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 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 updateFaq(List faqReqList, CallEntity callEntity, UserEntity userEntity, LookUpDataTypeEnum type) { + if (faqReqList == null) { + return null; + } + List existingFaqEntities = faqRepository.findByCallIdAndIsDeletedFalse(callEntity.getId()); + List 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 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 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 evaluationCriteriaEntities, List documentEntities, + List images) { + + CallResponse callResponseBean = convertToCallResponseBean(callEntity); + + List evaluationCriteriaResponseBeans = evaluationCriteriaEntities.stream() + .map(this::convertToEvaluationCriteriaResponseBean).collect(Collectors.toList()); + + List documentResponseBeans = documentEntities.stream() + .map(this::convertToDocumentResponseBean).collect(Collectors.toList()); + + + List 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 convertLookUpDataEntities(List lookUpData, CallEntity callEntity, + LookUpDataEntity.LookUpDataTypeEnum type) { + if(lookUpData == null) { + return null; + } + List lookUpDataEntities = lookUpData.stream() + .map(req -> lookUpDataService.getOrCreateLookUpDataEntity(req, type)).collect(Collectors.toList()); + + return createCallTargetAudienceCheckList(callEntity, lookUpDataEntities); + } + + private List createCallTargetAudienceCheckList(CallEntity callEntity, + List lookUpDataEntities) { + List 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 faqEntities = faqRepository.findByCallIdAndIsDeletedFalse(callEntity.getId()); +// List 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 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 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 lookupDataReqList, LookUpDataTypeEnum type) { + if (lookupDataReqList == null) { + return; + } + List existingChecklist = callTargetAudienceChecklistRepository + .findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), type.getValue()); + List 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 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 documentEntities = documentRepository.findBySourceIdAndTypeAndIsDeletedFalse(callEntity.getId(), + DocumentTypeEnum.DOCUMENT.getValue()); + List imageEntities = documentRepository.findBySourceIdAndTypeAndIsDeletedFalse(callEntity.getId(), + DocumentTypeEnum.IMAGES.getValue()); + List amiedTo = callTargetAudienceChecklistRepository + .findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.AIMED_TO.getValue()).stream() + .map(this::convertToLookUpDataResponseBean).toList(); + + List checkList = callTargetAudienceChecklistRepository + .findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.CHECKLIST.getValue()).stream() + .map(this::convertToLookUpDataResponseBean).toList(); + List 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 getAllCalls(UserEntity user) { + String type=user.getRoleEntity().getRoleType(); + List callStatusList =CallStatusEnum.getStatusValues(); + if (Boolean.FALSE.equals(ROLE_SUPER_ADMIN.getValue().equals(type))) { + callStatusList = List.of(CallStatusEnum.PUBLISH.getValue()); + } + List 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 = 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; + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/DocumentDao.java b/src/main/java/net/gepafin/tendermanagement/dao/DocumentDao.java new file mode 100644 index 00000000..374c741b --- /dev/null +++ b/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 uploadFiles(List files, Long sourceId, DocumentSourceTypeEnum sourceType, DocumentTypeEnum fileType) { + List 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); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/EvaluationCriteriaDao.java b/src/main/java/net/gepafin/tendermanagement/dao/EvaluationCriteriaDao.java new file mode 100644 index 00000000..f747d38f --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/FaqDao.java b/src/main/java/net/gepafin/tendermanagement/dao/FaqDao.java new file mode 100644 index 00000000..b8ebd278 --- /dev/null +++ b/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 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; + } + +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/dao/FlowDao.java b/src/main/java/net/gepafin/tendermanagement/dao/FlowDao.java new file mode 100644 index 00000000..6b4d34d5 --- /dev/null +++ b/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 flowDataEntities = createFlowData(flowRequestBean,call); + List 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 flowDataEntities = flowDataRepository.findByCallId(call.getId()); + List 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 createFlowEdgesResponseBean(List flowEdgesEntities) { + List flowEdgesResponseBeans = flowEdgesEntities.stream() + .map(this::convertFlowEdgesEntityToFlowEdgesResponseBean).collect(Collectors.toList()); + return flowEdgesResponseBeans; + } + + private List createFlowDataResponseBean(List flowDataEntities) { + List 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 createFlowData(FlowRequestBean flowRequestBean, CallEntity call) { + if (flowRequestBean.getFlowData() != null || !flowRequestBean.getFlowEdges().isEmpty()) { + List 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 createFlowEdges(FlowRequestBean flowRequestBean, CallEntity call) { + List 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 flowDataEntities=flowDataRepository.findByCallId(call.getId()); + List flowEdgesEntities=flowEdgesRepository.findByCallId(call.getId()); + List flowDataResponseBeans=createFlowDataResponseBean(flowDataEntities); + List 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; + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/FlowFormDao.java b/src/main/java/net/gepafin/tendermanagement/dao/FlowFormDao.java new file mode 100644 index 00000000..57f3c756 --- /dev/null +++ b/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 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 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 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 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 flowDataList = flowDataRepository.findByFormIdInAndCallId( +// previousFormIds, applicationEntity.getCall().getId()); +// +// List 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 formList = applicationFormFieldRepository +// .findByFieldValueInAndAndApplicationFormApplicationId( +// fieldValue, applicationEntity.getId()).stream().map(applicationFormFieldEntity->applicationFormFieldEntity.getApplicationForm().getForm()).collect(Collectors.toSet()); +// +// List 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 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 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 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 previousFormIds = flowEdgesList.stream() +// .map(FlowEdgesEntity::getSourceId) +// .toList(); +// +// // Fetch the flow data based on previous form IDs +// List flowDataList = flowDataRepository.findByFormIdInAndCallId( +// previousFormIds, applicationEntity.getCall().getId()); +// +// List chosenValues = flowDataList.stream() +// .map(FlowDataEntity::getChoosenValue) +// .toList(); +// +// // Fetch the previous forms based on the chosen field values +// Set 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 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 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 previousFormIds = flowEdgesList.stream() + .map(FlowEdgesEntity::getSourceId) + .toList(); + + List 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 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 applicationFormList = applicationFormRepository.findByApplicationId(applicationEntity.getId()); + List 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 flowEdgesList) { + Long totalFormSteps = 3l; + if (flowEdgesList.size() == 1) { + totalFormSteps = 2l; + } + return totalFormSteps; + } + + private Long getDefaultForm(ApplicationEntity applicationEntity) { + List 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); + } + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/FormDao.java b/src/main/java/net/gepafin/tendermanagement/dao/FormDao.java new file mode 100644 index 00000000..36ff8eb8 --- /dev/null +++ b/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 flowDataEntities=flowDataRepository.findByCallId(callId); + List 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 = 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 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 flowDataEntities = flowDataRepository.findByCallId(formEntity.getCall().getId()); + List 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 flowDataEntities=flowDataRepository.findByCallId(formEntity.getCall().getId()); + List 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 getFormsByCallId(Long callId){ + CallEntity callEntity=callService.validateCall(callId); + if(callEntity== null){ + throw new CustomValidationException(Status.VALIDATION_ERROR, + Translator.toLocale(GepafinConstant.CALL_NOT_FOUND)); + } + List formEntities=formRepository.findByCallId(callId); + List formResponseBeanList = formEntities.stream() + .map(req -> convertFormEntityToFormResponseBean(req)) + .collect(Collectors.toList()); + return formResponseBeanList; + } + public String setContentResponseBean(List contentRequestBeans){ + return Utils.convertListToJsonString(contentRequestBeans); + } + + public void validateFormField(List applicationFormFieldRequestList, ApplicationEntity applicationEntity, FormEntity formEntity) { + Map formFieldMap = new LinkedHashMap(); + 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 applicationFormFieldEntityList, ApplicationEntity applicationEntity, FormEntity formEntity) { + Map formFieldMap = new LinkedHashMap(); + 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 customData=null; + try { + Map 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; + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/FormFieldDao.java b/src/main/java/net/gepafin/tendermanagement/dao/FormFieldDao.java new file mode 100644 index 00000000..57f67694 --- /dev/null +++ b/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 settingRequestBeans) { + return Utils.convertListToJsonString(settingRequestBeans); + } + + public List getAllFormField() { + List formFieldEntities = formFieldRepository.findAll(); + List formFieldResponseBeans = formFieldEntities.stream() + .map(req -> convertFormFieldEntityToFormFieldResponseBean(req)).collect(Collectors.toList()); + return formFieldResponseBeans; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/FormTemplateDao.java b/src/main/java/net/gepafin/tendermanagement/dao/FormTemplateDao.java new file mode 100644 index 00000000..2042f2fa --- /dev/null +++ b/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 contentRequestBeans) { + return Utils.convertListToJsonString(contentRequestBeans); + } + + public List getAllFormTemplate() { + List formTemplateEntities = formTemplateRepository.findAll(); + List formTemplateResponseBeans = formTemplateEntities.stream() + .map(req -> convertFormTemplateEntityToFormTemplateResponseBean(req)).collect(Collectors.toList()); + return formTemplateResponseBeans; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/LookUpDataDao.java b/src/main/java/net/gepafin/tendermanagement/dao/LookUpDataDao.java new file mode 100644 index 00000000..1a31c306 --- /dev/null +++ b/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 getLookUpDataByTypes(List 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))); + } + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/RegionDao.java b/src/main/java/net/gepafin/tendermanagement/dao/RegionDao.java new file mode 100644 index 00000000..46643d3a --- /dev/null +++ b/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 getAllRegions() { + log.info("Fetching all regions"); + List regions = regionRepository.findAll() + .stream() + .map(regionEntity -> Utils.convertObject(regionEntity, RegionResponseBean.class)) + .collect(Collectors.toList()); + log.info("Total regions found: {}", regions.size()); + return regions; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/RoleDao.java b/src/main/java/net/gepafin/tendermanagement/dao/RoleDao.java new file mode 100644 index 00000000..cb4f41fd --- /dev/null +++ b/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 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 getAllRoles() { + log.info("Fetching all roles"); + List 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()); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/UserDao.java b/src/main/java/net/gepafin/tendermanagement/dao/UserDao.java new file mode 100644 index 00000000..252c88f7 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/dao/VatCheckDao.java b/src/main/java/net/gepafin/tendermanagement/dao/VatCheckDao.java new file mode 100644 index 00000000..4d1d0f58 --- /dev/null +++ b/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 checkVatNumberApi(String vatNumber) { + if (Boolean.TRUE.equals(Boolean.parseBoolean(isVatCheckGloballyDisabled))) { + return new HashMap<>(); + } + Map 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> response = vatCheckService.checkVatNumber(baseUrl,vatNumber, headers); + + if (response.getStatusCode() == HttpStatus.OK && response.hasBody()) { + log.info("Successfully checked vat number"); + Map responseMap = response.getBody(); + if (responseMap != null && responseMap.containsKey("data")) { + responseBody = (Map) responseMap.get("data"); + responseBody.remove("timestamp_creation"); + responseBody.remove("timestamp_last_update"); + responseBody.remove("data_iscrizione"); + responseBody.remove("id"); + Map 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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/ApplicationEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/ApplicationEntity.java new file mode 100644 index 00000000..8c9156e3 --- /dev/null +++ b/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; + + } \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/entities/ApplicationFormEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/ApplicationFormEntity.java new file mode 100644 index 00000000..a6cc56aa --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/ApplicationFormFieldEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/ApplicationFormFieldEntity.java new file mode 100644 index 00000000..fbab986d --- /dev/null +++ b/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; + +} + diff --git a/src/main/java/net/gepafin/tendermanagement/entities/BaseEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/BaseEntity.java new file mode 100644 index 00000000..f8427719 --- /dev/null +++ b/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()); + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/CallEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/CallEntity.java new file mode 100644 index 00000000..02c53fca --- /dev/null +++ b/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; +} + diff --git a/src/main/java/net/gepafin/tendermanagement/entities/CallTargetAudienceChecklistEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/CallTargetAudienceChecklistEntity.java new file mode 100644 index 00000000..6b14df58 --- /dev/null +++ b/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; + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/DocumentEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/DocumentEntity.java new file mode 100644 index 00000000..fc15a82d --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/EvaluationCriteriaEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/EvaluationCriteriaEntity.java new file mode 100644 index 00000000..39b3eb05 --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/FaqEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/FaqEntity.java new file mode 100644 index 00000000..38cd3b2b --- /dev/null +++ b/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; + +} + diff --git a/src/main/java/net/gepafin/tendermanagement/entities/FlowDataEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/FlowDataEntity.java new file mode 100644 index 00000000..cdffe410 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/FlowEdgesEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/FlowEdgesEntity.java new file mode 100644 index 00000000..119af700 --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/FormEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/FormEntity.java new file mode 100644 index 00000000..588619a5 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/FormFieldEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/FormFieldEntity.java new file mode 100644 index 00000000..b75b0c57 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/FormTemplateEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/FormTemplateEntity.java new file mode 100644 index 00000000..897a9dfd --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/LookUpDataEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/LookUpDataEntity.java new file mode 100644 index 00000000..1afe87aa --- /dev/null +++ b/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; + } + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/RegionEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/RegionEntity.java new file mode 100644 index 00000000..386b9787 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/RoleEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/RoleEntity.java new file mode 100644 index 00000000..c94b36b9 --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/SamlResponseEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/SamlResponseEntity.java new file mode 100644 index 00000000..732edfd9 --- /dev/null +++ b/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; + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/entities/UserEntity.java b/src/main/java/net/gepafin/tendermanagement/entities/UserEntity.java new file mode 100644 index 00000000..37b0ab57 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/enums/ApplicationStatusTypeEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/ApplicationStatusTypeEnum.java new file mode 100644 index 00000000..08b436c8 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/enums/CallStatusEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/CallStatusEnum.java new file mode 100644 index 00000000..2ae07e15 --- /dev/null +++ b/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 getStatusValues() { + return Arrays.stream(CallStatusEnum.values()) + .map(CallStatusEnum::getValue) + .collect(Collectors.toList()); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/enums/DocumentSourceTypeEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/DocumentSourceTypeEnum.java new file mode 100644 index 00000000..123c6f8c --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/enums/DocumentTypeEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/DocumentTypeEnum.java new file mode 100644 index 00000000..d5275796 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/enums/FormActionEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/FormActionEnum.java new file mode 100644 index 00000000..e5a64c59 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/enums/RegionStatusEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/RegionStatusEnum.java new file mode 100644 index 00000000..599e8ea2 --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/enums/RoleStatusEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/RoleStatusEnum.java new file mode 100644 index 00000000..3659856d --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/enums/UserStatusEnum.java b/src/main/java/net/gepafin/tendermanagement/enums/UserStatusEnum.java new file mode 100644 index 00000000..8df4f40b --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/model/BaseBean.java b/src/main/java/net/gepafin/tendermanagement/model/BaseBean.java new file mode 100644 index 00000000..49eb0d41 --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/ApplicationFormFieldRequestBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/ApplicationFormFieldRequestBean.java new file mode 100644 index 00000000..029eb470 --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/ApplicationRequest.java b/src/main/java/net/gepafin/tendermanagement/model/request/ApplicationRequest.java new file mode 100644 index 00000000..0eabdcb8 --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/ApplicationRequestBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/ApplicationRequestBean.java new file mode 100644 index 00000000..273519be --- /dev/null +++ b/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 formFields; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/ChangePasswordRequest.java b/src/main/java/net/gepafin/tendermanagement/model/request/ChangePasswordRequest.java new file mode 100644 index 00000000..a15f8cfc --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/ContentRequestBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/ContentRequestBean.java new file mode 100644 index 00000000..f0399ead --- /dev/null +++ b/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 settings; + private Map validators; + private Integer dbId; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/CreateCallRequestStep1.java b/src/main/java/net/gepafin/tendermanagement/model/request/CreateCallRequestStep1.java new file mode 100644 index 00000000..bfa0e84d --- /dev/null +++ b/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 dates; + + private Long regionId; + + private BigDecimal amount; + + private BigDecimal amountMax; + + private List aimedTo; + + private String documentationRequested; + + private Boolean confidi; + + private List faq; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/CreateCallRequestStep2.java b/src/main/java/net/gepafin/tendermanagement/model/request/CreateCallRequestStep2.java new file mode 100644 index 00000000..6538b672 --- /dev/null +++ b/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 criteria; + + private List checkList; + + private List docs; + + private List images; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/DocumentReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/DocumentReq.java new file mode 100644 index 00000000..a2f65bba --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/EvaluationCriteriaReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/EvaluationCriteriaReq.java new file mode 100644 index 00000000..7d504f7f --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/EvaluationCriteriaRequest.java b/src/main/java/net/gepafin/tendermanagement/model/request/EvaluationCriteriaRequest.java new file mode 100644 index 00000000..a2e5a92b --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FaqReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/FaqReq.java new file mode 100644 index 00000000..0018689e --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FieldValidatorBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/FieldValidatorBean.java new file mode 100644 index 00000000..be94ffc0 --- /dev/null +++ b/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; + +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FlowDataRequestBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/FlowDataRequestBean.java new file mode 100644 index 00000000..58432432 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FlowEdgesRequestBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/FlowEdgesRequestBean.java new file mode 100644 index 00000000..57a0e7a7 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FlowRequestBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/FlowRequestBean.java new file mode 100644 index 00000000..eb938e19 --- /dev/null +++ b/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 flowData; + + private List flowEdges; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FormFieldRequest.java b/src/main/java/net/gepafin/tendermanagement/model/request/FormFieldRequest.java new file mode 100644 index 00000000..9cc1b19f --- /dev/null +++ b/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 settings; + + private Map validators; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FormRequest.java b/src/main/java/net/gepafin/tendermanagement/model/request/FormRequest.java new file mode 100644 index 00000000..118ec040 --- /dev/null +++ b/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 content; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/FormTemplateRequest.java b/src/main/java/net/gepafin/tendermanagement/model/request/FormTemplateRequest.java new file mode 100644 index 00000000..7e587852 --- /dev/null +++ b/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 content; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/InitiatePasswordResetReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/InitiatePasswordResetReq.java new file mode 100644 index 00000000..ae2ba0d0 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/LoginReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/LoginReq.java new file mode 100644 index 00000000..d337d231 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/LogoutReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/LogoutReq.java new file mode 100644 index 00000000..e655f6bb --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/LookUpDataReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/LookUpDataReq.java new file mode 100644 index 00000000..e3ffc634 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/LookUpDataRequest.java b/src/main/java/net/gepafin/tendermanagement/model/request/LookUpDataRequest.java new file mode 100644 index 00000000..98e15d52 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/RegionReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/RegionReq.java new file mode 100644 index 00000000..1fd415ee --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/ResetPasswordReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/ResetPasswordReq.java new file mode 100644 index 00000000..019ca582 --- /dev/null +++ b/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; + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/RoleReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/RoleReq.java new file mode 100644 index 00000000..cd5e81d1 --- /dev/null +++ b/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 permissions; + + private Long regionId; + + private String roleType; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/SettingRequestBean.java b/src/main/java/net/gepafin/tendermanagement/model/request/SettingRequestBean.java new file mode 100644 index 00000000..fc724554 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/UpdateCallRequestStep1.java b/src/main/java/net/gepafin/tendermanagement/model/request/UpdateCallRequestStep1.java new file mode 100644 index 00000000..4d4de6e9 --- /dev/null +++ b/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 dates; + + private BigDecimal amount; + + private BigDecimal amountMax; + + private List aimedTo; + + private String documentationRequested; + + private Boolean confidi; + + private List faq; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/UpdateRegionReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/UpdateRegionReq.java new file mode 100644 index 00000000..1b62d403 --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/UpdateUserReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/UpdateUserReq.java new file mode 100644 index 00000000..65eba841 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/request/UserReq.java b/src/main/java/net/gepafin/tendermanagement/model/request/UserReq.java new file mode 100644 index 00000000..c53d65aa --- /dev/null +++ b/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; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationFormFieldResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationFormFieldResponseBean.java new file mode 100644 index 00000000..2e207f21 --- /dev/null +++ b/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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationGetResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationGetResponseBean.java new file mode 100644 index 00000000..50ce0c57 --- /dev/null +++ b/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 form; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationResponse.java b/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationResponse.java new file mode 100644 index 00000000..b5a0fbb2 --- /dev/null +++ b/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; + +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/ApplicationResponseBean.java new file mode 100644 index 00000000..e621197c --- /dev/null +++ b/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 formFields; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/CallDetailsResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/CallDetailsResponseBean.java new file mode 100644 index 00000000..a7bf60b7 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/CallDetailsResponseBean.java @@ -0,0 +1,44 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.enums.CallStatusEnum; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; +@Data +public class CallDetailsResponseBean { + + private Long id; + + private String name; + + private String descriptionShort; + + private String descriptionLong; + + private List dates; + + private CallStatusEnum status; + + private Long regionId; + + private BigDecimal amount; + + private BigDecimal amountMax; + + private String contactInfo; + + private String submissionMethod; + + private Long threshold; + + private String priorityArea; + + private String documentationRequested; + + private LocalDateTime createdDate; + + private LocalDateTime updatedDate; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/CallResponse.java b/src/main/java/net/gepafin/tendermanagement/model/response/CallResponse.java new file mode 100644 index 00000000..f8fa4908 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/CallResponse.java @@ -0,0 +1,64 @@ +package net.gepafin.tendermanagement.model.response; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; + +import lombok.Data; +import net.gepafin.tendermanagement.enums.CallStatusEnum; + +@Data +public class CallResponse { + + private Long id; + + private String name; + + private String descriptionShort; + + private String descriptionLong; + + private List dates; + + private CallStatusEnum status; + + private Long regionId; + + private BigDecimal amount; + + private BigDecimal amountMax; + + private String contactInfo; + + private String submissionMethod; + + private Long threshold; + + private String priorityArea; + + private String documentationRequested; + + private Boolean confidi; + + private LocalDateTime createdDate; + + private LocalDateTime updatedDate; + + private List aimedTo; + + private List criteria; + + private List docs; + + private List faq; + + private List images; + + private List checkList; + + private String currentStep; + +} + + + diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/CallResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/CallResponseBean.java new file mode 100644 index 00000000..0efff823 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/CallResponseBean.java @@ -0,0 +1,42 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +import java.math.BigDecimal; +import java.time.LocalDateTime; + +@Data +public class CallResponseBean { + + + private Long id; + + private String title; + + private String description; + + private LocalDateTime startDate; + + private LocalDateTime endDate; + + private String status; + + private RegionResponseBean region; + + private BigDecimal fundingAmount; + + private String contactInfo; + + private String submissionMethod; + + private Integer totalScore; + + private Integer minimumScore; + + private String priorityArea; + + private LocalDateTime createdDate; + + private LocalDateTime updatedDate; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/ContentResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/ContentResponseBean.java new file mode 100644 index 00000000..6ee1367d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/ContentResponseBean.java @@ -0,0 +1,17 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +import java.util.List; +import java.util.Map; + +@Data +public class ContentResponseBean { + + private String id; + private String name; + private String label; + private List settings; + private Map validators; + private Integer dbId; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/DocumentResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/DocumentResponseBean.java new file mode 100644 index 00000000..f5706b10 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/DocumentResponseBean.java @@ -0,0 +1,28 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum; +import net.gepafin.tendermanagement.enums.DocumentTypeEnum; + + +import java.time.LocalDateTime; + +@Data +public class DocumentResponseBean { + + private Long id; + + private String name; + + private String filePath; + + private DocumentTypeEnum type; + + private DocumentSourceTypeEnum source; + + private Long sourceId; + + private LocalDateTime createdDate; + + private LocalDateTime updatedDate; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/EvaluationCriteriaResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/EvaluationCriteriaResponseBean.java new file mode 100644 index 00000000..50a984cc --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/EvaluationCriteriaResponseBean.java @@ -0,0 +1,11 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.model.BaseBean; + + +@Data +public class EvaluationCriteriaResponseBean extends LookUpDataResponse{ + + private Long score; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FaqResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/FaqResponseBean.java new file mode 100644 index 00000000..133e3327 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FaqResponseBean.java @@ -0,0 +1,24 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.model.BaseBean; + + +import java.time.LocalDateTime; + +@Data +public class FaqResponseBean extends BaseBean { + + private Long userId; + + private String title; + + private String value; + + private String response; + + private LocalDateTime responseDate; + + private Boolean isVisible; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FlowDataResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/FlowDataResponseBean.java new file mode 100644 index 00000000..f95a8f2c --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FlowDataResponseBean.java @@ -0,0 +1,16 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.model.BaseBean; + +@Data +public class FlowDataResponseBean { + + private Long id; + + private Long formId; + + private String chosenField; + + private String chosenValue; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FlowEdgesResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/FlowEdgesResponseBean.java new file mode 100644 index 00000000..9424a79a --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FlowEdgesResponseBean.java @@ -0,0 +1,16 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.model.BaseBean; +import org.springframework.security.core.parameters.P; + +@Data +public class FlowEdgesResponseBean { + private String id; + + private String source; + + private String target; + + private String type; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FlowResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/FlowResponseBean.java new file mode 100644 index 00000000..d97895e7 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FlowResponseBean.java @@ -0,0 +1,25 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.enums.CallStatusEnum; +import net.gepafin.tendermanagement.model.request.FlowDataRequestBean; +import net.gepafin.tendermanagement.model.request.FlowEdgesRequestBean; + +import java.util.List; + +@Data +public class FlowResponseBean { + + private Long callId; + + private CallStatusEnum callStatus; + + private Long initialForm; + + private Long finalForm; + + private List flowData; + + private List flowEdges; +} + diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FormApplicationResponse.java b/src/main/java/net/gepafin/tendermanagement/model/response/FormApplicationResponse.java new file mode 100644 index 00000000..5ee40bb9 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FormApplicationResponse.java @@ -0,0 +1,19 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +import java.util.List; + +@Data +public class FormApplicationResponse { + + private Long id; + + private String label; + + private Long callId; + + private List content; + + private List formFields; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FormFieldResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/FormFieldResponseBean.java new file mode 100644 index 00000000..1650241d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FormFieldResponseBean.java @@ -0,0 +1,25 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +import java.util.List; +import java.util.Map; + +@Data +public class FormFieldResponseBean { + + private Long id; + + private String name; + + private String label; + + private String description; + + private Integer sortOrder; + + + private List settings; + + private Map validators; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FormResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/FormResponseBean.java new file mode 100644 index 00000000..7a1d178e --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FormResponseBean.java @@ -0,0 +1,19 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +import java.util.List; + +@Data +public class FormResponseBean { + + private Long id; + + private String callStatus; + + private String label; + + private Long callId; + + private List content; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/FormTemplateResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/FormTemplateResponseBean.java new file mode 100644 index 00000000..9e9503d5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/FormTemplateResponseBean.java @@ -0,0 +1,16 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +import java.util.List; + +@Data +public class FormTemplateResponseBean { + + private Long id; + + private String label; + + private List content; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/LoginResponse.java b/src/main/java/net/gepafin/tendermanagement/model/response/LoginResponse.java new file mode 100644 index 00000000..6317724e --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/LoginResponse.java @@ -0,0 +1,46 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import java.time.LocalDateTime; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class LoginResponse { + private Long id; + + private String email; + + private String firstName; + + private String lastName; + + private RoleResponseBean role; + + private String phoneNumber; + + private String organization; + + private String address; + + private String city; + + private String country; + + private String status; + + private LocalDateTime lastLogin; + + private String codiceFiscale; + + private LocalDateTime dateOfBirth; + + private LocalDateTime createdDate; + + private LocalDateTime updatedDate; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/LookUpDataResponse.java b/src/main/java/net/gepafin/tendermanagement/model/response/LookUpDataResponse.java new file mode 100644 index 00000000..d61e20d0 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/LookUpDataResponse.java @@ -0,0 +1,17 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.model.BaseBean; + +@Data +public class LookUpDataResponse extends BaseBean { + + private Long lookUpDataId; + + private String title; + + private String value; + + private String response; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/LookUpDataResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/LookUpDataResponseBean.java new file mode 100644 index 00000000..b3c873de --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/LookUpDataResponseBean.java @@ -0,0 +1,17 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum; +import net.gepafin.tendermanagement.model.BaseBean; + +@Data +public class LookUpDataResponseBean extends BaseBean { + + private String title; + + private String value; + + private String response; + + private LookUpDataTypeEnum type; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/NextOrPreviousFormResponse.java b/src/main/java/net/gepafin/tendermanagement/model/response/NextOrPreviousFormResponse.java new file mode 100644 index 00000000..0c39d4a9 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/NextOrPreviousFormResponse.java @@ -0,0 +1,25 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum; + +@Data +public class NextOrPreviousFormResponse { + + private Long formId; + + private Long callId; + + private String callTitle; + + private Long totalFormSteps; + + private Long completedSteps; + + private Long currentStep; + + private ApplicationStatusTypeEnum applicationStatus; + + private FormApplicationResponse applicationFormResponse; + +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/RegionResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/RegionResponseBean.java new file mode 100644 index 00000000..2a5459a4 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/RegionResponseBean.java @@ -0,0 +1,24 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.enums.RegionStatusEnum; +import net.gepafin.tendermanagement.model.BaseBean; + +import java.math.BigDecimal; + +@Data +public class RegionResponseBean extends BaseBean { + 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; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/RoleResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/RoleResponseBean.java new file mode 100644 index 00000000..0f0cda0d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/RoleResponseBean.java @@ -0,0 +1,15 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; +import net.gepafin.tendermanagement.model.BaseBean; + +import java.util.List; + +@Data +public class RoleResponseBean extends BaseBean { + private String roleName; + private String description; + private List permissions; + private RegionResponseBean region; + private String roleType; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/SettingResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/SettingResponseBean.java new file mode 100644 index 00000000..49f208cb --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/SettingResponseBean.java @@ -0,0 +1,11 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +@Data +public class SettingResponseBean { + + private String name; + + private Object value; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/UserResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/UserResponseBean.java new file mode 100644 index 00000000..565e2561 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/UserResponseBean.java @@ -0,0 +1,40 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Getter; +import lombok.Setter; +import net.gepafin.tendermanagement.enums.UserStatusEnum; +import net.gepafin.tendermanagement.model.BaseBean; + +import java.time.LocalDateTime; + +@Getter +@Setter +public class UserResponseBean extends BaseBean { + + private String email; + + private String firstName; + + private String lastName; + + private RoleResponseBean role; + + private String phoneNumber; + + private String organization; + + private String address; + + private String city; + + private String country; + + private UserStatusEnum status; + + private LocalDateTime lastLogin; + + private String codiceFiscale; + + private LocalDateTime dateOfBirth; + +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/UserSamlResponse.java b/src/main/java/net/gepafin/tendermanagement/model/response/UserSamlResponse.java new file mode 100644 index 00000000..da732bd4 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/UserSamlResponse.java @@ -0,0 +1,13 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +@Data +public class UserSamlResponse { + + private String codiceFiscale; + + private String firstName; + + private String lastName; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/response/VatNumberResponseBean.java b/src/main/java/net/gepafin/tendermanagement/model/response/VatNumberResponseBean.java new file mode 100644 index 00000000..f98e60c5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/response/VatNumberResponseBean.java @@ -0,0 +1,15 @@ +package net.gepafin.tendermanagement.model.response; + +import lombok.Data; + +@Data +public class VatNumberResponseBean { + + private Boolean valid; + + private String validation; + + private String companyName; + + private String errorMessage; +} diff --git a/src/main/java/net/gepafin/tendermanagement/model/util/JWTToken.java b/src/main/java/net/gepafin/tendermanagement/model/util/JWTToken.java new file mode 100644 index 00000000..a57b7d59 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/util/JWTToken.java @@ -0,0 +1,24 @@ +package net.gepafin.tendermanagement.model.util; + +import com.fasterxml.jackson.annotation.JsonProperty; + +import lombok.Data; +import net.gepafin.tendermanagement.model.response.LoginResponse; + +/** + * JWTToken + */ +@Data +public class JWTToken { + @JsonProperty("token") + private String token; + + @JsonProperty("user") + private LoginResponse loginResponse; + public JWTToken(String token, LoginResponse loginResponse) { + this.token = token; + this.loginResponse = loginResponse; + } + +} + diff --git a/src/main/java/net/gepafin/tendermanagement/model/util/Response.java b/src/main/java/net/gepafin/tendermanagement/model/util/Response.java new file mode 100644 index 00000000..7d0c768d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/model/util/Response.java @@ -0,0 +1,29 @@ +package net.gepafin.tendermanagement.model.util; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; + +import java.io.Serializable; + +/** + * A generic response class used for API responses. + * + * @param the type of the response data + */ +@JsonIgnoreProperties(ignoreUnknown = true) +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class Response implements Serializable { + + private static final long serialVersionUID = 1L; + + private T data; // The response data + private Status status; // The status of the response + private String message; // Additional message or error description +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationFormFieldRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationFormFieldRepository.java new file mode 100644 index 00000000..89c70488 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationFormFieldRepository.java @@ -0,0 +1,27 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.ApplicationFormFieldEntity; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; +import java.util.Optional; + +@Repository +public interface ApplicationFormFieldRepository extends JpaRepository { + + public List findByApplicationFormIdIn(List applicationFormIds); + + public List findByApplicationFormId(Long applicationFormId); + + public Optional findByFieldIdAndApplicationFormFormIdAndApplicationFormApplicationId( + String fieldId, Long formId, Long applicationId); + + public Optional findByFieldValueInAndApplicationFormFormIdInAndApplicationFormApplicationId( + List fieldValues, List previousFormIds, Long applicationId); + + public List findByFieldValueInAndApplicationFormApplicationId( + List fieldValue, Long applicationId); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationFormRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationFormRepository.java new file mode 100644 index 00000000..1037402a --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationFormRepository.java @@ -0,0 +1,21 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.ApplicationFormEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface ApplicationFormRepository extends JpaRepository { + + public ApplicationFormEntity findByApplicationIdAndFormId(Long applicationId,Long formId); + + List findByApplicationIdIn(List applicationIds); + + public List findByApplicationId(Long applicationId); + + public List findByApplicationIdOrderByCreatedDateAsc(Long applicationId); + + public List findByFormIdInAndApplicationId(List formIds,Long applicationId); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationRepository.java new file mode 100644 index 00000000..ad9104a5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/ApplicationRepository.java @@ -0,0 +1,29 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.ApplicationEntity; +import net.gepafin.tendermanagement.entities.FaqEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import java.util.List; +import java.util.Optional; + +@Repository +public interface ApplicationRepository extends JpaRepository { + + public Optional findByUserIdAndCallIdAndIsDeletedFalse(Long userId,Long callId); + + public List findByUserIdAndIsDeletedFalse(Long userId); + + @Query("SELECT a FROM ApplicationEntity a WHERE a.id = :id AND a.isDeleted = false") + Optional findById(@Param("id") Long id); + + public List findByCallIdAndIsDeletedFalse(Long callId); + + public List findByIsDeletedFalse(); + + public Optional findByIdAndUserIdAndIsDeletedFalse(Long id,Long userId); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/CallRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/CallRepository.java new file mode 100644 index 00000000..6fa6bbde --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/CallRepository.java @@ -0,0 +1,16 @@ +package net.gepafin.tendermanagement.repositories; +import net.gepafin.tendermanagement.entities.CallEntity; +import net.gepafin.tendermanagement.enums.CallStatusEnum; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface CallRepository extends JpaRepository { + + public CallEntity findByIdAndStatusNotIn(Long id, List status); + List findByStatusIn(List callStatus); + + public CallEntity findByIdAndStatus(Long id,String status); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/CallTargetAudienceChecklistRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/CallTargetAudienceChecklistRepository.java new file mode 100644 index 00000000..62da59a7 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/CallTargetAudienceChecklistRepository.java @@ -0,0 +1,20 @@ +package net.gepafin.tendermanagement.repositories; + +import java.util.List; +import java.util.Optional; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import net.gepafin.tendermanagement.entities.CallTargetAudienceChecklistEntity; + +@Repository +public interface CallTargetAudienceChecklistRepository extends JpaRepository { + + @Query("SELECT c FROM CallTargetAudienceChecklistEntity c WHERE c.id = :id AND c.isDeleted = false") + Optional findById(@Param("id") Long id); + + List findByCallIdAndLookupDataTypeAndIsDeletedFalse(Long id, String type); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/DocumentRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/DocumentRepository.java new file mode 100644 index 00000000..40361cd9 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/DocumentRepository.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.repositories; +import net.gepafin.tendermanagement.entities.DocumentEntity; + +import java.util.List; +import java.util.Optional; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +@Repository +public interface DocumentRepository extends JpaRepository { + + @Query("SELECT d FROM DocumentEntity d WHERE d.id = :id AND d.isDeleted = false") + Optional findById(@Param("id") Long id); + + List findBySourceIdAndTypeAndIsDeletedFalse(Long sourceId, String type); + + Optional findByIdAndSourceIdAndIsDeletedFalse(Long id, Long sourceId); + +} + diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/EvaluationCriteriaRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/EvaluationCriteriaRepository.java new file mode 100644 index 00000000..b5b9a231 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/EvaluationCriteriaRepository.java @@ -0,0 +1,19 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.EvaluationCriteriaEntity; + +import java.util.List; +import java.util.Optional; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +@Repository +public interface EvaluationCriteriaRepository extends JpaRepository { + @Query("SELECT ec FROM EvaluationCriteriaEntity ec WHERE ec.id = :id AND ec.isDeleted = false") + Optional findById(@Param("id") Long id); + + List findByCallIdAndLookupDataTypeAndIsDeletedFalse(Long callId, String type); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/FaqRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/FaqRepository.java new file mode 100644 index 00000000..3727e4ef --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/FaqRepository.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.FaqEntity; + +import java.util.List; +import java.util.Optional; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +@Repository +public interface FaqRepository extends JpaRepository { + + @Query("SELECT f FROM FaqEntity f WHERE f.id = :id AND f.isDeleted = false") + Optional findById(@Param("id") Long id); + + List findByCallIdAndIsDeletedFalse(Long callId); + + Optional findByIdAndCallIdAndIsDeletedFalse(Long id, Long callId); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/FlowDataRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/FlowDataRepository.java new file mode 100644 index 00000000..dffaee53 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/FlowDataRepository.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.FlowDataEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; +import java.util.Optional; + +@Repository +public interface FlowDataRepository extends JpaRepository { + + public List findByCallId(Long callId); + + public FlowDataEntity findByFormIdAndCallId(Long formId, Long callId); + + public Optional findByChoosenValueAndFormIdIn(String fieldValue, List nextFormIds); + + public List findByFormIdInAndCallId(List previousFormIds, Long callId); + + public FlowDataEntity findByFormIdAndChoosenField(Long formId, String choosenField); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/FlowEdgesRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/FlowEdgesRepository.java new file mode 100644 index 00000000..3de65c17 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/FlowEdgesRepository.java @@ -0,0 +1,17 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.FlowEdgesEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface FlowEdgesRepository extends JpaRepository { + + public List findByCallId(Long callId); + + public List findBySourceIdAndCallId(Long sourceId, Long callId); + + public List findByTargetIdAndCallId(Long targetId, Long callId); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/FormFieldRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/FormFieldRepository.java new file mode 100644 index 00000000..358e4cf9 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/FormFieldRepository.java @@ -0,0 +1,9 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.FormFieldEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface FormFieldRepository extends JpaRepository { +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/FormRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/FormRepository.java new file mode 100644 index 00000000..db35477f --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/FormRepository.java @@ -0,0 +1,15 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.FormEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface FormRepository extends JpaRepository { + + List findByCallId(Long callId); + + List findByIdIn(List formId); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/FormTemplateRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/FormTemplateRepository.java new file mode 100644 index 00000000..f9ce4f4d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/FormTemplateRepository.java @@ -0,0 +1,9 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.FormTemplateEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface FormTemplateRepository extends JpaRepository { +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/LookUpDataRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/LookUpDataRepository.java new file mode 100644 index 00000000..67edec0a --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/LookUpDataRepository.java @@ -0,0 +1,12 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.LookUpDataEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface LookUpDataRepository extends JpaRepository { + List findByType(String type); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/RegionRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/RegionRepository.java new file mode 100644 index 00000000..87dfdfa0 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/RegionRepository.java @@ -0,0 +1,9 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.RegionEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface RegionRepository extends JpaRepository { +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/RoleRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/RoleRepository.java new file mode 100644 index 00000000..a48eade5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/RoleRepository.java @@ -0,0 +1,11 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.RoleEntity; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface RoleRepository extends JpaRepository { + + RoleEntity findByRoleType(String roleType); +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/SamlResponseRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/SamlResponseRepository.java new file mode 100644 index 00000000..9183f339 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/SamlResponseRepository.java @@ -0,0 +1,13 @@ +package net.gepafin.tendermanagement.repositories; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import net.gepafin.tendermanagement.entities.SamlResponseEntity; + +@Repository +public interface SamlResponseRepository extends JpaRepository { + + SamlResponseEntity findByToken(String token); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/repositories/UserRepository.java b/src/main/java/net/gepafin/tendermanagement/repositories/UserRepository.java new file mode 100644 index 00000000..68289e6d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/repositories/UserRepository.java @@ -0,0 +1,19 @@ +package net.gepafin.tendermanagement.repositories; + +import net.gepafin.tendermanagement.entities.UserEntity; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; + +public interface UserRepository extends JpaRepository { + + Optional findByEmailIgnoreCase(String email); + + boolean existsByEmailIgnoreCase(String email); + + UserEntity findByEmail(String email); + + Optional findByCodiceFiscale(String cf); + + boolean existsByCodiceFiscale(String codiceFiscale); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/AmazonS3Service.java b/src/main/java/net/gepafin/tendermanagement/service/AmazonS3Service.java new file mode 100644 index 00000000..1ff3a7fd --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/AmazonS3Service.java @@ -0,0 +1,17 @@ +package net.gepafin.tendermanagement.service; + +import org.springframework.stereotype.Component; +import org.springframework.web.multipart.MultipartFile; + +import java.io.IOException; +import java.io.InputStream; + +@Component +public interface AmazonS3Service { + + public String upload(String fileName, MultipartFile file) throws IOException; + + public Boolean delete(String fileName); + + InputStream getFile(String filePath) throws IOException; +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/service/ApplicationService.java b/src/main/java/net/gepafin/tendermanagement/service/ApplicationService.java new file mode 100644 index 00000000..152bc1b5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/ApplicationService.java @@ -0,0 +1,33 @@ +package net.gepafin.tendermanagement.service; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.entities.ApplicationEntity; +import net.gepafin.tendermanagement.model.request.ApplicationRequest; +import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum; +import net.gepafin.tendermanagement.enums.FormActionEnum; +import net.gepafin.tendermanagement.model.request.ApplicationRequestBean; +import net.gepafin.tendermanagement.model.response.ApplicationGetResponseBean; +import net.gepafin.tendermanagement.model.response.ApplicationResponse; +import net.gepafin.tendermanagement.model.response.ApplicationResponseBean; +import net.gepafin.tendermanagement.model.response.NextOrPreviousFormResponse; + +import java.util.List; + +public interface ApplicationService { + + public ApplicationResponseBean createApplication(HttpServletRequest request, ApplicationRequestBean applicationRequestBean,Long applicationId, Long formId); + + ApplicationGetResponseBean getApplicationByFormId(HttpServletRequest request, Long applicationId,Long formId); + + List getAllApplications(HttpServletRequest request,Long callId); + + void deleteApplication(HttpServletRequest request, Long applicationId); + + public ApplicationEntity validateApplication(Long userId); + + public ApplicationResponse createApplication(HttpServletRequest request, ApplicationRequest applicationRequest, Long callId); + + public NextOrPreviousFormResponse getNextOrPreviousForm(HttpServletRequest request, Long applicationId, Long formId, FormActionEnum action); + + public void updateApplicationStatus(HttpServletRequest request, Long applicationId, ApplicationStatusTypeEnum status); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/CallService.java b/src/main/java/net/gepafin/tendermanagement/service/CallService.java new file mode 100644 index 00000000..aa6ea872 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/CallService.java @@ -0,0 +1,36 @@ +package net.gepafin.tendermanagement.service; + +import java.util.List; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.entities.CallEntity; +import net.gepafin.tendermanagement.enums.CallStatusEnum; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep1; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep2; +import net.gepafin.tendermanagement.model.request.UpdateCallRequestStep1; +import net.gepafin.tendermanagement.model.response.CallDetailsResponseBean; +import net.gepafin.tendermanagement.model.response.CallResponse; + +public interface CallService { + + CallResponse createCallStep1(HttpServletRequest request, CreateCallRequestStep1 createCallRequest); + + CallResponse createCallStep2(HttpServletRequest request, Long callId, CreateCallRequestStep2 createCallRequest); + + CallResponse updateCallStep1(HttpServletRequest request, Long callId, UpdateCallRequestStep1 updateCallRequest); + + CallResponse getCallById (Long callId); + + List getAllCalls(HttpServletRequest request); + + CallResponse validateCallData(Long callId); + + CallEntity getCallEntityById(Long id); + + CallResponse updateCallStatus(HttpServletRequest request, Long callId, CallStatusEnum statusReq); + + CallEntity validateCall(Long callId); + + CallEntity validatePublishedCall(Long callId); + + } diff --git a/src/main/java/net/gepafin/tendermanagement/service/DocumentService.java b/src/main/java/net/gepafin/tendermanagement/service/DocumentService.java new file mode 100644 index 00000000..6012a273 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/DocumentService.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.service; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.entities.DocumentEntity; +import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum; +import net.gepafin.tendermanagement.enums.DocumentTypeEnum; +import net.gepafin.tendermanagement.model.response.DocumentResponseBean; +import org.springframework.web.multipart.MultipartFile; + +import java.util.List; + +public interface DocumentService { + + public List uploadFile(List files, Long sourceId, DocumentSourceTypeEnum sourceType, DocumentTypeEnum fileType); + + public void deleteFile(Long documentId); + + public DocumentResponseBean updateDocument(HttpServletRequest httpServletRequest, Long documentId, MultipartFile file, DocumentTypeEnum documentTypeEnum); + + public DocumentResponseBean getDocument(HttpServletRequest httpServletRequest,Long documentId); + + public DocumentEntity validateDocument(Long id); + } diff --git a/src/main/java/net/gepafin/tendermanagement/service/EvaluationCriteriaService.java b/src/main/java/net/gepafin/tendermanagement/service/EvaluationCriteriaService.java new file mode 100644 index 00000000..3c1e2b85 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/EvaluationCriteriaService.java @@ -0,0 +1,16 @@ +package net.gepafin.tendermanagement.service; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.model.request.EvaluationCriteriaRequest; +import net.gepafin.tendermanagement.model.response.EvaluationCriteriaResponseBean; + +public interface EvaluationCriteriaService { + + public EvaluationCriteriaResponseBean createEvaluationCriteria(HttpServletRequest request,EvaluationCriteriaRequest evaluationCriteriaRequest); + + public EvaluationCriteriaResponseBean getEvaluationCriteria(HttpServletRequest request,Long id); + + public EvaluationCriteriaResponseBean updateEvaluationCriteria(HttpServletRequest request,Long id, EvaluationCriteriaRequest evaluationCriteriaRequest); + + public void deleteEvaluationCriteria(HttpServletRequest request,Long id); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/FaqService.java b/src/main/java/net/gepafin/tendermanagement/service/FaqService.java new file mode 100644 index 00000000..55adc950 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/FaqService.java @@ -0,0 +1,26 @@ +package net.gepafin.tendermanagement.service; +import java.util.List; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.entities.CallEntity; +import net.gepafin.tendermanagement.entities.FaqEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum; +import net.gepafin.tendermanagement.model.request.FaqReq; +import net.gepafin.tendermanagement.model.response.FaqResponseBean; + +public interface FaqService { + + FaqResponseBean createFaq(HttpServletRequest request,Long callId, FaqReq faqRequest); + + FaqResponseBean getFaqById(HttpServletRequest request, Long id); + + FaqResponseBean updateFaq(HttpServletRequest request, Long id, FaqReq faqRequest); + + void deleteFaq(HttpServletRequest request, Long id); + + FaqEntity createOrUpdateFaqEntity(FaqReq faqReq, CallEntity callEntity, UserEntity userEntity, + LookUpDataTypeEnum type); + + List getFaqByCallId(Long id); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/FlowService.java b/src/main/java/net/gepafin/tendermanagement/service/FlowService.java new file mode 100644 index 00000000..7c38a01f --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/FlowService.java @@ -0,0 +1,12 @@ +package net.gepafin.tendermanagement.service; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.model.request.FlowRequestBean; +import net.gepafin.tendermanagement.model.response.FlowResponseBean; + +public interface FlowService { + + public FlowResponseBean createOrUpdateFlow(HttpServletRequest httpServletRequest, FlowRequestBean flowRequestBean, Long callId); + + public FlowResponseBean getFlowByCallId(HttpServletRequest request, Long callId); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/FormFieldService.java b/src/main/java/net/gepafin/tendermanagement/service/FormFieldService.java new file mode 100644 index 00000000..87261dfe --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/FormFieldService.java @@ -0,0 +1,24 @@ +package net.gepafin.tendermanagement.service; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.entities.FormFieldEntity; +import net.gepafin.tendermanagement.model.request.FormFieldRequest; +import net.gepafin.tendermanagement.model.response.FormFieldResponseBean; + +import java.util.List; + +public interface FormFieldService { + + public FormFieldResponseBean createFormField(HttpServletRequest request, FormFieldRequest formFieldRequest); + + public FormFieldResponseBean updateFormField(HttpServletRequest request, Long formFieldId, FormFieldRequest formFieldRequest); + + public FormFieldResponseBean getFormFieldById(HttpServletRequest request, Long formFieldId); + + public void deleteFormField(HttpServletRequest request, Long formFieldId); + + public FormFieldEntity validateFormField(Long id); + + public List getAllFormField(HttpServletRequest request); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/FormService.java b/src/main/java/net/gepafin/tendermanagement/service/FormService.java new file mode 100644 index 00000000..84447ebb --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/FormService.java @@ -0,0 +1,28 @@ +package net.gepafin.tendermanagement.service; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.entities.ApplicationEntity; +import net.gepafin.tendermanagement.entities.FormEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.model.request.ApplicationFormFieldRequestBean; +import net.gepafin.tendermanagement.model.request.FormRequest; +import net.gepafin.tendermanagement.model.response.FormResponseBean; + +import java.util.List; + +public interface FormService { + + public FormResponseBean createForm(HttpServletRequest request,Long callId,FormRequest formRequest); + + public FormResponseBean updateForm(HttpServletRequest request, Long formId, FormRequest formRequest,Boolean forceDeleteFlow); + + public FormResponseBean getFormById(HttpServletRequest request, Long formId); + + public void deleteForm(HttpServletRequest request, Long formId); + + public FormEntity validateForm(Long id); + + public List getFormsByCallId(HttpServletRequest request,Long callId); + + void validateFormField(List formFields, ApplicationEntity applicationEntity, FormEntity formEntity); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/FormTemplateService.java b/src/main/java/net/gepafin/tendermanagement/service/FormTemplateService.java new file mode 100644 index 00000000..c50cd8c6 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/FormTemplateService.java @@ -0,0 +1,24 @@ +package net.gepafin.tendermanagement.service; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.entities.FormTemplateEntity; +import net.gepafin.tendermanagement.model.request.FormTemplateRequest; +import net.gepafin.tendermanagement.model.response.FormTemplateResponseBean; + +import java.util.List; + +public interface FormTemplateService { + + public FormTemplateResponseBean createTemplateForm(HttpServletRequest request, FormTemplateRequest formTemplateRequest); + + public FormTemplateResponseBean updateTemplateForm(HttpServletRequest request, Long formTemplateId, FormTemplateRequest formTemplateRequest); + + public FormTemplateResponseBean getFormTemplateById(HttpServletRequest request, Long formTemplateId); + + public void deleteFormTemplate(HttpServletRequest request, Long formTemplateId); + + public FormTemplateEntity validateFormTemplate(Long id); + + public List getAllFormTemplate(HttpServletRequest request); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/LookUpDataService.java b/src/main/java/net/gepafin/tendermanagement/service/LookUpDataService.java new file mode 100644 index 00000000..24767dc3 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/LookUpDataService.java @@ -0,0 +1,28 @@ +package net.gepafin.tendermanagement.service; + +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 java.util.List; + +public interface LookUpDataService { + + LookUpDataResponseBean createLookUpData(LookUpDataRequest lookUpDataReq); + + LookUpDataResponseBean getLookUpDataById(Long id); + + LookUpDataResponseBean updateLookUpData(Long id, LookUpDataRequest lookUpDataReq); + + void deleteLookUpData(Long id); + void validateLookUpDataEntity(LookUpDataEntity lookUpDataEntity); + + List getLookUpDataByType(List type); + + LookUpDataEntity validateLookUpData(Long lookUpDataId); + + LookUpDataEntity getOrCreateLookUpDataEntity(LookUpDataReq req, + LookUpDataEntity.LookUpDataTypeEnum type); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/RegionService.java b/src/main/java/net/gepafin/tendermanagement/service/RegionService.java new file mode 100644 index 00000000..aba66fe5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/RegionService.java @@ -0,0 +1,20 @@ +package net.gepafin.tendermanagement.service; + +import net.gepafin.tendermanagement.model.request.RegionReq; +import net.gepafin.tendermanagement.model.response.RegionResponseBean; + +import java.util.List; + + +public interface RegionService { + + RegionResponseBean createRegion(RegionReq regionReq); + + RegionResponseBean updateRegion(Long regionId, RegionReq regionReq); + + RegionResponseBean getRegionById(Long regionId); + + void deleteRegion(Long regionId); + + List getAllRegions(); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/RoleService.java b/src/main/java/net/gepafin/tendermanagement/service/RoleService.java new file mode 100644 index 00000000..6c9c519d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/RoleService.java @@ -0,0 +1,18 @@ +package net.gepafin.tendermanagement.service; + +import net.gepafin.tendermanagement.model.request.RoleReq; +import net.gepafin.tendermanagement.model.response.RoleResponseBean; + +import java.util.List; + +public interface RoleService { + RoleResponseBean createRole(RoleReq roleReq); + + RoleResponseBean updateRole(Long roleId, RoleReq roleReq); + + RoleResponseBean getRoleById(Long roleId); + + void deleteRole(Long roleId); + + List getAllRoles(); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/UserService.java b/src/main/java/net/gepafin/tendermanagement/service/UserService.java new file mode 100644 index 00000000..57421978 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/UserService.java @@ -0,0 +1,43 @@ +package net.gepafin.tendermanagement.service; + +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.model.request.LoginReq; +import net.gepafin.tendermanagement.model.request.UpdateUserReq; +import net.gepafin.tendermanagement.model.request.UserReq; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import net.gepafin.tendermanagement.enums.UserStatusEnum; +import net.gepafin.tendermanagement.model.request.*; +import net.gepafin.tendermanagement.model.response.UserSamlResponse; +import net.gepafin.tendermanagement.model.response.UserResponseBean; +import net.gepafin.tendermanagement.model.util.JWTToken; + +public interface UserService { + JWTToken createUser(HttpServletRequest request, String tempToken, UserReq userReq); + + UserResponseBean updateUser(Long userId, UpdateUserReq userReq); + + UserResponseBean getUserById(Long userId); + + void deleteUser(Long userId); + + JWTToken login(LoginReq loginReq); + + UserEntity validateUser(Long userId); + + String initiatePasswordReset(InitiatePasswordResetReq resetReq); + + Boolean resetPassword(ResetPasswordReq resetPasswordReq); + + Boolean changePassword(ChangePasswordRequest request); + + void logoutUser(HttpServletRequest request, HttpServletResponse response); + + UserResponseBean updateUserStatus(Long userId, UserStatusEnum statusReq); + + UserResponseBean getValidUser(HttpServletRequest request); + + JWTToken validateExistingUserToken(HttpServletRequest request, String token); + + UserSamlResponse validateNewUserToken(HttpServletRequest request, String token); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/feignClient/VatCheckService.java b/src/main/java/net/gepafin/tendermanagement/service/feignClient/VatCheckService.java new file mode 100644 index 00000000..6665690d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/feignClient/VatCheckService.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.service.feignClient; + +import net.gepafin.tendermanagement.constants.GepafinConstant; +import org.springframework.cloud.openfeign.FeignClient; +import org.springframework.http.HttpHeaders; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestHeader; + +import java.net.URI; +import java.util.Map; + +@FeignClient(value = "vat-check-service", url = GepafinConstant.VATNUMBER_V2) +public interface VatCheckService { + + + @GetMapping("/{vatNumber}") + ResponseEntity> checkVatNumber(URI baseUrl, + @PathVariable("vatNumber") String vatNumber, + @RequestHeader HttpHeaders headers + ); +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/AmazonS3ServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/AmazonS3ServiceImpl.java new file mode 100644 index 00000000..3657d115 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/AmazonS3ServiceImpl.java @@ -0,0 +1,91 @@ +package net.gepafin.tendermanagement.service.impl; + +import com.amazonaws.services.s3.AmazonS3; +import com.amazonaws.services.s3.model.*; +import net.gepafin.tendermanagement.service.AmazonS3Service; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.core.env.Environment; +import org.springframework.stereotype.Service; +import org.springframework.web.multipart.MultipartFile; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + + +@Service +public class AmazonS3ServiceImpl implements AmazonS3Service { + + @Autowired + private AmazonS3 amazonS3; + + @Autowired + private Environment environment; + + @Value("${aws.s3.bucket.name}") + private String bucketName; + + @Value("${aws.s3.url.folder}") + private String s3Folder; + + @Value("${aws.s3.url}") + private String s3Url; + + + @Override + public String upload(String fileName, + MultipartFile file) throws IOException { + + String path = bucketName+"/"+s3Folder; + + InputStream inputStream = file.getInputStream(); + + ObjectMetadata objectMetadata = new ObjectMetadata(); + Map metadata = new HashMap<>(); + metadata.put("Content-Type", file.getContentType()); + metadata.put("Content-Length", String.valueOf(file.getSize())); + + Optional> optionalMetaData = Optional.of(metadata); + optionalMetaData.ifPresent(map -> { + if (!map.isEmpty()) { + map.forEach(objectMetadata::addUserMetadata); + } + }); + + if(Boolean.FALSE.equals(isTestProfileActivated())) { + amazonS3.putObject(path, fileName, inputStream, objectMetadata); + } + return s3Url + s3Folder +"/"+ fileName; + } + + @Override + public Boolean delete(String fileName) { + + final DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest(bucketName, fileName); + if(Boolean.FALSE.equals(isTestProfileActivated())) { + amazonS3.deleteObject(deleteObjectRequest); + } + return true; + } + + public Boolean isTestProfileActivated() { + String[] activeProfiles = environment.getActiveProfiles(); + return Arrays.stream(activeProfiles).anyMatch("test"::equals); + } + + @Override + public InputStream getFile(String filePath) throws IOException { + try { + String path = bucketName+ s3Folder +"/"; + GetObjectRequest getObjectRequest = new GetObjectRequest(path, filePath); + S3Object s3Object = amazonS3.getObject(getObjectRequest); + return s3Object.getObjectContent(); + } catch (AmazonS3Exception e) { + throw new IOException("Error getting file from Amazon S3", e); + } + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/ApplicationServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/ApplicationServiceImpl.java new file mode 100644 index 00000000..e2364698 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/ApplicationServiceImpl.java @@ -0,0 +1,87 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.ApplicationDao; +import net.gepafin.tendermanagement.dao.FlowFormDao; +import net.gepafin.tendermanagement.entities.ApplicationEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.model.request.ApplicationRequest; +import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum; +import net.gepafin.tendermanagement.enums.FormActionEnum; +import net.gepafin.tendermanagement.model.request.ApplicationRequestBean; +import net.gepafin.tendermanagement.model.response.ApplicationGetResponseBean; +import net.gepafin.tendermanagement.model.response.ApplicationResponse; +import net.gepafin.tendermanagement.model.response.ApplicationResponseBean; +import net.gepafin.tendermanagement.model.response.NextOrPreviousFormResponse; +import net.gepafin.tendermanagement.service.ApplicationService; +import net.gepafin.tendermanagement.util.Validator; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +@Service +public class ApplicationServiceImpl implements ApplicationService { + + @Autowired + private ApplicationDao applicationDao; + + @Autowired + private FlowFormDao flowFormDao; + + @Autowired + private Validator validator; + + @Override + @Transactional(rollbackFor = Exception.class) + public ApplicationResponseBean createApplication(HttpServletRequest request, ApplicationRequestBean applicationRequestBean,Long applicationId, Long formId) { + UserEntity userEntity = validator.validateUser(request); + return applicationDao.createApplication(applicationRequestBean,userEntity,formId,applicationId); + } + + @Override + @Transactional(readOnly = true) + public ApplicationGetResponseBean getApplicationByFormId(HttpServletRequest request, Long applicationId,Long formId) { + UserEntity userEntity = validator.validateUser(request); + return applicationDao.getApplicationByFormId(applicationId,formId,userEntity); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public void deleteApplication(HttpServletRequest request, Long applicationId) { + applicationDao.deleteById(applicationId); + } + + @Override + public ApplicationEntity validateApplication(Long id) { + return applicationDao.validateApplication(id); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public ApplicationResponse createApplication(HttpServletRequest request, ApplicationRequest applicationRequest, Long callId) { + UserEntity userEntity = validator.validateUser(request); + return applicationDao.createApplicationByCallId(applicationRequest,callId,userEntity); + } + + @Override + public NextOrPreviousFormResponse getNextOrPreviousForm(HttpServletRequest request, Long applicationId, Long formId, + FormActionEnum action) { + ApplicationEntity applicationEntity = validateApplication(applicationId); + return flowFormDao.getnextOrPreviousForm(applicationEntity, formId, action); + } + + @Override + public void updateApplicationStatus(HttpServletRequest request, Long applicationId, ApplicationStatusTypeEnum status) { + applicationDao.updateApplicationStatus(applicationId, status); + + } + + @Override + @Transactional(readOnly = true) + public List getAllApplications(HttpServletRequest request,Long callId) { + UserEntity userEntity = validator.validateUser(request); + return applicationDao.getAllApplications(userEntity,callId); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/AuthenticationService.java b/src/main/java/net/gepafin/tendermanagement/service/impl/AuthenticationService.java new file mode 100644 index 00000000..457a1e5d --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/AuthenticationService.java @@ -0,0 +1,171 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.config.jwt.TokenProvider; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.dao.RoleDao; +import net.gepafin.tendermanagement.entities.SamlResponseEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.enums.UserStatusEnum; +import net.gepafin.tendermanagement.model.request.LoginReq; +import net.gepafin.tendermanagement.model.response.LoginResponse; +import net.gepafin.tendermanagement.model.response.RoleResponseBean; +import net.gepafin.tendermanagement.model.response.UserSamlResponse; +import net.gepafin.tendermanagement.model.util.JWTToken; +import net.gepafin.tendermanagement.repositories.SamlResponseRepository; +import net.gepafin.tendermanagement.repositories.UserRepository; +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.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.security.authentication.AuthenticationManager; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +@Service +public class AuthenticationService { + + private final Logger log = LoggerFactory.getLogger(AuthenticationService.class); + + private final TokenProvider tokenProvider; + private final AuthenticationManager authenticationManager; + + @Autowired + private UserRepository userRepository; + + @Autowired + private RoleDao roleDao; + + @Autowired + private SamlResponseRepository samlResponseLogRepository; + + @Autowired + public AuthenticationService(TokenProvider tokenProvider, AuthenticationManager authenticationManager) { + this.tokenProvider = tokenProvider; + this.authenticationManager = authenticationManager; + } + + public JWTToken login(LoginReq loginReq) { + log.info("Attempting login for email: {}", loginReq.getEmail()); + UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken( + loginReq.getEmail(), loginReq.getPassword()); + Authentication authentication = this.authenticationManager.authenticate(authenticationToken); + SecurityContextHolder.getContext().setAuthentication(authentication); + log.info("Authentication successful for email: {}", loginReq.getEmail()); + UserEntity user = userRepository.findByEmailIgnoreCase(loginReq.getEmail()) + .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, + Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG))); + if (Boolean.FALSE.equals(UserStatusEnum.ACTIVE.getValue().equals(user.getStatus()))) { + throw new ResourceNotFoundException(Status.NOT_FOUND, + Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG)); + } + return getJWTTokenBean(user, loginReq.getRememberMe()); + } + + public JWTToken getJWTTokenBean(UserEntity user, Boolean rememberMe) { + user.setLastLogin(DateTimeUtil.DateServerToUTC(LocalDateTime.now())); + userRepository.save(user); + String token = tokenProvider.createToken(rememberMe, user); + log.info("JWT token generated for email: {}", user.getEmail()); + RoleResponseBean roleResponseBean = roleDao.convertRoleEntityToRoleResponse(user.getRoleEntity()); + + LoginResponse loginResponse = getLoginResponse(user, roleResponseBean); + + JWTToken jwtToken = new JWTToken(token, loginResponse); + + log.info("Login successful for email: {}", user.getEmail()); + return jwtToken; + } + + private static LoginResponse getLoginResponse(UserEntity user, RoleResponseBean roleResponseBean) { + LoginResponse loginResponse = new LoginResponse(); + loginResponse.setId(user.getId()); + loginResponse.setEmail(user.getEmail()); + loginResponse.setFirstName(user.getFirstName()); + loginResponse.setLastName(user.getLastName()); + loginResponse.setRole(roleResponseBean); + loginResponse.setPhoneNumber(user.getPhoneNumber()); + loginResponse.setAddress(user.getAddress()); + loginResponse.setOrganization(user.getOrganization()); + loginResponse.setCountry(user.getCountry()); + loginResponse.setStatus(user.getStatus()); + loginResponse.setCity(user.getCity()); + loginResponse.setLastLogin(user.getLastLogin()); + loginResponse.setCodiceFiscale(user.getCodiceFiscale()); + loginResponse.setDateOfBirth(user.getDateOfBirth()); + loginResponse.setCreatedDate(user.getCreatedDate()); + loginResponse.setUpdatedDate(user.getUpdatedDate()); + return loginResponse; + } + public void logout(HttpServletRequest request, HttpServletResponse response) { + Authentication auth = SecurityContextHolder.getContext().getAuthentication(); + if (auth != null) { + String token = tokenProvider.extractTokenFromRequest(request); + tokenProvider.invalidateToken(token); + new SecurityContextLogoutHandler().logout(request, response, auth); + } + SecurityContextHolder.getContext().setAuthentication(null); + SecurityContextHolder.clearContext(); + } + + public JWTToken validateExistingUserToken(String token) { + SamlResponseEntity samlResponseLogEntity = samlResponseLogRepository.findByToken(token); + if (samlResponseLogEntity == null) { + log.info("Invalid spid login token : {}", token); + throw new CustomValidationException(Status.VALIDATION_ERROR, + Translator.toLocale(GepafinConstant.INVALID_TOKEN_MSG)); + } + Map> userAttributes = Utils + .convertStringIntoMap(samlResponseLogEntity.getAuthenticationObject()); + String cf = userAttributes.get("CodiceFiscale").get(0).toString(); + UserEntity userEntity = userRepository.findByCodiceFiscale(cf) + .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, + Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG))); + samlResponseLogRepository.delete(samlResponseLogEntity); + + return getJWTTokenBean(userEntity, Boolean.TRUE); + } + + + public UserSamlResponse validateNewUserToken(String token) { + SamlResponseEntity samlResponseLogEntity = samlResponseLogRepository.findByToken(token); + if (samlResponseLogEntity == null) { + log.info("Invalid spid login token : {}", token); + throw new CustomValidationException(Status.VALIDATION_ERROR, + Translator.toLocale(GepafinConstant.INVALID_TOKEN_MSG)); + } + Map> userAttributes = Utils + .convertStringIntoMap(samlResponseLogEntity.getAuthenticationObject()); + String cf = userAttributes.get("CodiceFiscale").get(0).toString(); + if (userRepository.findByCodiceFiscale(cf).isPresent()) { + throw new ResourceNotFoundException(Status.NOT_FOUND, + Translator.toLocale(GepafinConstant.USER_ALREADY_EXIST_MSG)); + } + UserSamlResponse userSamlResponse = new UserSamlResponse(); + userSamlResponse.setCodiceFiscale(cf); + if (userAttributes.containsKey("nome") && userAttributes.get("nome") != null + && !userAttributes.get("nome").isEmpty()) { + userSamlResponse.setFirstName(userAttributes.get("nome").get(0).toString()); + } + if (userAttributes.containsKey("cognome") && userAttributes.get("cognome") != null + && !userAttributes.get("cognome").isEmpty()) { + userSamlResponse.setLastName(userAttributes.get("cognome").get(0).toString()); + } + userSamlResponse.setCodiceFiscale(cf); + return userSamlResponse; + } +} + diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/CallServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/CallServiceImpl.java new file mode 100644 index 00000000..a6a6a901 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/CallServiceImpl.java @@ -0,0 +1,95 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.jwt.TokenProvider; +import net.gepafin.tendermanagement.dao.CallDao; +import net.gepafin.tendermanagement.entities.CallEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.enums.CallStatusEnum; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep1; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep2; +import net.gepafin.tendermanagement.model.request.UpdateCallRequestStep1; +import net.gepafin.tendermanagement.model.response.CallDetailsResponseBean; +import net.gepafin.tendermanagement.model.response.CallResponse; +import net.gepafin.tendermanagement.service.CallService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; +import java.util.Map; + + +@Service +public class CallServiceImpl implements CallService { + + @Autowired + private CallDao callDao; + + @Autowired + private TokenProvider tokenProvider; + + @Override + @Transactional(rollbackFor = Exception.class) + public CallResponse createCallStep1(HttpServletRequest request, CreateCallRequestStep1 createCallRequest) { + Map userInfo= tokenProvider.getUserInfoAndUserIdFromToken(request); + return callDao.createCallStep1(createCallRequest, Long.parseLong(userInfo.get("userId").toString())); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public CallResponse createCallStep2(HttpServletRequest request, Long callId, CreateCallRequestStep2 createCallRequest) { + Map userInfo= tokenProvider.getUserInfoAndUserIdFromToken(request); + return callDao.createCallStep2(callId, createCallRequest, Long.parseLong(userInfo.get("userId").toString())); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public CallResponse updateCallStep1(HttpServletRequest request, Long callId, + UpdateCallRequestStep1 updateCallRequest) { + Map userInfo= tokenProvider.getUserInfoAndUserIdFromToken(request); + return callDao.updateCallStep1(callId, updateCallRequest, Long.parseLong(userInfo.get("userId").toString())); + } + @Override + @Transactional(readOnly = true) + public CallResponse getCallById(Long callId) { + return callDao.getCallById(callId); + } + + @Override + @Transactional(readOnly = true) + public List getAllCalls(HttpServletRequest request) { + Map userInfo= tokenProvider.getUserInfoAndUserIdFromToken(request); + UserEntity user=tokenProvider.validateUser(userInfo); + return callDao.getAllCalls(user); + + } + + @Override + @Transactional(rollbackFor = Exception.class) + public CallResponse validateCallData(Long callId) { + return callDao.validateCallData(callDao.validateCall(callId)); + } + + @Override + public CallEntity getCallEntityById(Long id){ + return callDao.getCallEntityById(id); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public CallResponse updateCallStatus(HttpServletRequest request, Long callId, CallStatusEnum statusReq) { + return callDao.updateCallStatus(callId, statusReq); + + } + + @Override + public CallEntity validateCall(Long callId) { + return callDao.validateCall(callId); + } + + @Override + public CallEntity validatePublishedCall(Long callId) { + return callDao.validatePublishedCall(callId); + } + } diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/CallValidatorServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/CallValidatorServiceImpl.java new file mode 100644 index 00000000..715242f5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/CallValidatorServiceImpl.java @@ -0,0 +1,53 @@ +package net.gepafin.tendermanagement.service.impl; + +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.List; + +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.response.CallResponse; +import net.gepafin.tendermanagement.model.response.FlowResponseBean; +import net.gepafin.tendermanagement.model.response.FormResponseBean; +import net.gepafin.tendermanagement.util.FieldValidator; +import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; + +public class CallValidatorServiceImpl { + public static void validateResponse(CallResponse response, FlowResponseBean flowResponse, List formResponses) { + // Validate CallResponse (existing logic) + FieldValidator data = FieldValidator.create() + .notNull(response.getId(), "id") + .notNull(response.getName(), "name") + .notNull(response.getDescriptionShort(), "descriptionShort") + .notNull(response.getDescriptionLong(), "descriptionLong") + .notNull(response.getDates().get(0), "startDate") + .notNull(response.getDates().get(1), "endDate") + .notNull(response.getStatus(), "status") + .notNull(response.getRegionId(), "regionId") + .notNull(response.getAmount(), "amount") + .notNull(response.getAmountMax(), "amountMax") + .notNull(response.getThreshold(), "threshold") + .notNull(response.getDocumentationRequested(), "documentationRequested") + .notEmpty(response.getAimedTo(), "aimedTo") + .notEmpty(response.getCriteria(), "criteria") + .notEmpty(response.getDocs(), "docs") + .notEmpty(response.getCheckList(), "checkList"); + + + if (response.getDates().get(0) == null || response.getDates().get(1) == null + || response.getDates().get(0).toLocalDate().isBefore(LocalDate.now()) + || response.getDates().get(1).toLocalDate().isBefore(LocalDate.now()) + || response.getDates().get(0).toLocalDate().isAfter(response.getDates().get(1).toLocalDate())) { + data = data.addError(Translator.toLocale(GepafinConstant.INVALID_DATE_MSG)); + } + if (flowResponse == null || ((flowResponse.getFlowData() == null || flowResponse.getFlowData().isEmpty()) + && (flowResponse.getFlowEdges() == null || flowResponse.getFlowEdges().isEmpty()))) { + data.addError(Translator.toLocale(GepafinConstant.FLOW_NOT_FOUND)); + } + if (formResponses == null || formResponses.isEmpty()) { + data.addError(Translator.toLocale(GepafinConstant.FORM_NOT_FOUND)); + } + data.validate(); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/DocumentServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/DocumentServiceImpl.java new file mode 100644 index 00000000..3b3fa310 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/DocumentServiceImpl.java @@ -0,0 +1,50 @@ +package net.gepafin.tendermanagement.service.impl; + +import java.util.List; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.DocumentDao; +import net.gepafin.tendermanagement.entities.DocumentEntity; +import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum; +import net.gepafin.tendermanagement.enums.DocumentTypeEnum; +import net.gepafin.tendermanagement.model.response.DocumentResponseBean; +import net.gepafin.tendermanagement.service.DocumentService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.web.multipart.MultipartFile; + + + +@Service +public class DocumentServiceImpl implements DocumentService { + + + @Autowired + private DocumentDao documentDao; + + @Override + public List uploadFile(List files, Long sourceId, DocumentSourceTypeEnum sourceType, DocumentTypeEnum fileType) { + return documentDao.uploadFiles(files,sourceId,sourceType,fileType); + } + @Override + public void deleteFile(Long documentId){ + documentDao.deleteFile(documentId); + return ; + } + + @Override + public DocumentResponseBean updateDocument(HttpServletRequest httpServletRequest, Long documentId, MultipartFile file, DocumentTypeEnum documentTypeEnum) { + return documentDao.updateDocument(documentId,file,documentTypeEnum); + } + + @Override + public DocumentResponseBean getDocument(HttpServletRequest httpServletRequest, Long documentId) { + return documentDao.getDocument(documentId); + } + + @Override + public DocumentEntity validateDocument(Long id){ + return documentDao.validateDocument(id); + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/EvaluationCriteriaServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/EvaluationCriteriaServiceImpl.java new file mode 100644 index 00000000..2aef9e5f --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/EvaluationCriteriaServiceImpl.java @@ -0,0 +1,36 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.EvaluationCriteriaDao; +import net.gepafin.tendermanagement.model.request.EvaluationCriteriaRequest; +import net.gepafin.tendermanagement.model.response.EvaluationCriteriaResponseBean; +import net.gepafin.tendermanagement.service.EvaluationCriteriaService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class EvaluationCriteriaServiceImpl implements EvaluationCriteriaService { + + @Autowired + private EvaluationCriteriaDao evaluationCriteriaDao; + + @Override + public EvaluationCriteriaResponseBean createEvaluationCriteria(HttpServletRequest request,EvaluationCriteriaRequest evaluationCriteriaRequest) { + return evaluationCriteriaDao.createEvaluationCriteria(evaluationCriteriaRequest); + } + + @Override + public EvaluationCriteriaResponseBean getEvaluationCriteria(HttpServletRequest request,Long id) { + return evaluationCriteriaDao.getEvaluationCriteriaById(id); + } + + @Override + public EvaluationCriteriaResponseBean updateEvaluationCriteria(HttpServletRequest request,Long id, EvaluationCriteriaRequest evaluationCriteriaRequest) { + return evaluationCriteriaDao.updateEvaluationCriteria(id,evaluationCriteriaRequest); + } + + @Override + public void deleteEvaluationCriteria(HttpServletRequest request,Long id) { + evaluationCriteriaDao.deleteEvaluationCriteria(id); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/FaqServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/FaqServiceImpl.java new file mode 100644 index 00000000..78a458f3 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/FaqServiceImpl.java @@ -0,0 +1,60 @@ +package net.gepafin.tendermanagement.service.impl; +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.FaqDao; +import net.gepafin.tendermanagement.entities.CallEntity; +import net.gepafin.tendermanagement.entities.FaqEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +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.service.FaqService; +import net.gepafin.tendermanagement.util.Validator; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class FaqServiceImpl implements FaqService { + + @Autowired + private FaqDao faqDao; + + @Autowired + private Validator validator; + + @Override + public FaqResponseBean createFaq(HttpServletRequest request,Long callId, FaqReq faqRequest) { + UserEntity userEntity = validator.validateUser(request); + return faqDao.createFaq(faqRequest, userEntity,callId); + } + + @Override + public FaqResponseBean getFaqById(HttpServletRequest request, Long id) { + return faqDao.getFaqById(id); + } + + @Override + public FaqResponseBean updateFaq(HttpServletRequest request, Long id, FaqReq faqRequest) { + UserEntity userEntity = validator.validateUser(request); + return faqDao.updateFaq(id, faqRequest, userEntity); + } + + @Override + public void deleteFaq(HttpServletRequest request, Long id) { + faqDao.deleteFaq(id); + } + + @Override + public FaqEntity createOrUpdateFaqEntity(FaqReq faqReq, CallEntity callEntity, UserEntity userEntity, + LookUpDataTypeEnum type) { + return faqDao.createOrUpdateFaqEntity(faqReq, callEntity, userEntity, type); + } + + @Override + public List getFaqByCallId(Long callId) { + return faqDao.getFaqByCallId(callId); + } +} + diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/FlowServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/FlowServiceImpl.java new file mode 100644 index 00000000..2ae5546f --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/FlowServiceImpl.java @@ -0,0 +1,29 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.FlowDao; +import net.gepafin.tendermanagement.model.request.FlowRequestBean; +import net.gepafin.tendermanagement.model.response.FlowResponseBean; +import net.gepafin.tendermanagement.service.FlowService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +public class FlowServiceImpl implements FlowService { + + @Autowired + private FlowDao flowDao; + + @Override + @Transactional(rollbackFor = Exception.class) + public FlowResponseBean createOrUpdateFlow(HttpServletRequest httpServletRequest, FlowRequestBean flowRequestBean, Long callId) { + return flowDao.createOrUpdateFlow(flowRequestBean,callId); + } + + @Override + @org.springframework.transaction.annotation.Transactional(readOnly = true) + public FlowResponseBean getFlowByCallId(HttpServletRequest request, Long callId) { + return flowDao.getFlowByCallId(callId); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/FormFieldServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/FormFieldServiceImpl.java new file mode 100644 index 00000000..37741e6e --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/FormFieldServiceImpl.java @@ -0,0 +1,50 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.FormFieldDao; +import net.gepafin.tendermanagement.entities.FormFieldEntity; +import net.gepafin.tendermanagement.model.request.FormFieldRequest; +import net.gepafin.tendermanagement.model.response.FormFieldResponseBean; +import net.gepafin.tendermanagement.service.FormFieldService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class FormFieldServiceImpl implements FormFieldService { + + @Autowired + private FormFieldDao formFieldDao; + + @Override + public FormFieldResponseBean createFormField(HttpServletRequest request, FormFieldRequest formFieldRequest) { + return formFieldDao.createFormField(formFieldRequest); + } + + @Override + public FormFieldResponseBean updateFormField(HttpServletRequest request, Long formFieldId, FormFieldRequest formFieldRequest) { + return formFieldDao.updateFormField(formFieldId,formFieldRequest); + } + + @Override + public FormFieldResponseBean getFormFieldById(HttpServletRequest request, Long formFieldId) { + return formFieldDao.getFormFieldEntityById(formFieldId); + } + + @Override + public void deleteFormField(HttpServletRequest request, Long formFieldId) { + formFieldDao.deleteFormById(formFieldId); + return; + } + + @Override + public FormFieldEntity validateFormField(Long id) { + return formFieldDao.validateFormField(id); + } + + @Override + public List getAllFormField(HttpServletRequest request) { + return formFieldDao.getAllFormField(); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/FormServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/FormServiceImpl.java new file mode 100644 index 00000000..9d04dbc5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/FormServiceImpl.java @@ -0,0 +1,59 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.FormDao; +import net.gepafin.tendermanagement.entities.ApplicationEntity; +import net.gepafin.tendermanagement.entities.FormEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.model.request.ApplicationFormFieldRequestBean; +import net.gepafin.tendermanagement.model.request.FormRequest; +import net.gepafin.tendermanagement.model.response.FormResponseBean; +import net.gepafin.tendermanagement.service.FormService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class FormServiceImpl implements FormService { + + @Autowired + private FormDao formDao; + + @Override + public FormResponseBean createForm(HttpServletRequest request,Long callId, FormRequest formRequest) { + return formDao.createForm(callId,formRequest); + } + + @Override + public FormResponseBean updateForm(HttpServletRequest request, Long formId, FormRequest formRequest,Boolean forceDeleteFlow) { + return formDao.updateForm(formId,formRequest,forceDeleteFlow); + } + + @Override + public FormResponseBean getFormById(HttpServletRequest request, Long formId) { + return formDao.getFormEntityById(formId); + } + + @Override + public void deleteForm(HttpServletRequest request, Long formId) { + formDao.deleteFormById(formId); + return; + } + + @Override + public FormEntity validateForm(Long id) { + return formDao.validateForm(id); + } + + @Override + public List getFormsByCallId(HttpServletRequest request, Long callId) { + return formDao.getFormsByCallId(callId); + } + + @Override + public void validateFormField(List formFields, ApplicationEntity applicationEntity, FormEntity formEntity) { + formDao.validateFormField(formFields,applicationEntity, formEntity); + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/FormTemplateServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/FormTemplateServiceImpl.java new file mode 100644 index 00000000..f594cf20 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/FormTemplateServiceImpl.java @@ -0,0 +1,50 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.dao.FormTemplateDao; +import net.gepafin.tendermanagement.entities.FormTemplateEntity; +import net.gepafin.tendermanagement.model.request.FormTemplateRequest; +import net.gepafin.tendermanagement.model.response.FormTemplateResponseBean; +import net.gepafin.tendermanagement.service.FormTemplateService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class FormTemplateServiceImpl implements FormTemplateService { + + @Autowired + private FormTemplateDao formTemplateDao; + + @Override + public FormTemplateResponseBean createTemplateForm(HttpServletRequest request, FormTemplateRequest formTemplateRequest) { + return formTemplateDao.createFormTemplate(formTemplateRequest); + } + + @Override + public FormTemplateResponseBean updateTemplateForm(HttpServletRequest request, Long formTemplateId, FormTemplateRequest formTemplateRequest) { + return formTemplateDao.updateFormTemplate(formTemplateId,formTemplateRequest); + } + + @Override + public FormTemplateResponseBean getFormTemplateById(HttpServletRequest request, Long formTemplateId) { + return formTemplateDao.getFormTemplateEntityById(formTemplateId); + } + + @Override + public void deleteFormTemplate(HttpServletRequest request, Long formTemplateId) { + formTemplateDao.deleteFormTemplateById(formTemplateId); + } + + @Override + public FormTemplateEntity validateFormTemplate(Long id) { + return formTemplateDao.validateFormTemplate(id); + } + + @Override + public List getAllFormTemplate(HttpServletRequest request) { + List formTemplateResponseBeans=formTemplateDao.getAllFormTemplate(); + return formTemplateResponseBeans; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/LookUpDataServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/LookUpDataServiceImpl.java new file mode 100644 index 00000000..3d53c8fa --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/LookUpDataServiceImpl.java @@ -0,0 +1,59 @@ +package net.gepafin.tendermanagement.service.impl; + +import net.gepafin.tendermanagement.dao.LookUpDataDao; +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.service.LookUpDataService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class LookUpDataServiceImpl implements LookUpDataService { + + @Autowired + private LookUpDataDao lookUpDataDao; + + @Override + public LookUpDataResponseBean createLookUpData(LookUpDataRequest lookUpDataReq) { + return lookUpDataDao.createLookUpData(lookUpDataReq); + } + + @Override + public LookUpDataResponseBean getLookUpDataById(Long id) { + return lookUpDataDao.getLookUpDataById(id); + } + + @Override + public LookUpDataResponseBean updateLookUpData(Long id, LookUpDataRequest lookUpDataReq) { + return lookUpDataDao.updateLookUpData(id, lookUpDataReq); + } + + public void validateLookUpDataEntity(LookUpDataEntity lookUpDataEntity) + { + lookUpDataDao.validateLookUpDataEntity(lookUpDataEntity); + } + @Override + public void deleteLookUpData(Long id) { + lookUpDataDao.deleteLookUpData(id); + } + @Override + public List getLookUpDataByType( List type) { + return lookUpDataDao.getLookUpDataByTypes(type); + } + + @Override + public LookUpDataEntity validateLookUpData(Long lookUpDataId) { + return lookUpDataDao.validateLookUpData(lookUpDataId); + } + + @Override + public LookUpDataEntity getOrCreateLookUpDataEntity(LookUpDataReq req, + LookUpDataEntity.LookUpDataTypeEnum type) { + return lookUpDataDao.getOrCreateLookUpDataEntity(req, type); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/RegionServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/RegionServiceImpl.java new file mode 100644 index 00000000..cd6776a9 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/RegionServiceImpl.java @@ -0,0 +1,48 @@ +package net.gepafin.tendermanagement.service.impl; + +import java.util.List; + +import net.gepafin.tendermanagement.dao.RegionDao; +import net.gepafin.tendermanagement.model.request.RegionReq; +import net.gepafin.tendermanagement.model.response.RegionResponseBean; +import net.gepafin.tendermanagement.service.RegionService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +public class RegionServiceImpl implements RegionService { + + @Autowired + private RegionDao regionDao; + + @Override + @Transactional(rollbackFor = Exception.class) + public RegionResponseBean createRegion(RegionReq regionReq) { + return regionDao.createRegion(regionReq); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public RegionResponseBean updateRegion(Long regionId, RegionReq regionReq) { + return regionDao.updateRegion(regionId,regionReq); + } + + @Override + @Transactional(readOnly = true) + public RegionResponseBean getRegionById(Long regionId) { + return regionDao.getRegionById(regionId); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public void deleteRegion(Long regionId) { + regionDao.deleteById(regionId); + } + + @Override + @Transactional(readOnly = true) + public List getAllRegions() { + return regionDao.getAllRegions(); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/RoleServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/RoleServiceImpl.java new file mode 100644 index 00000000..49fd86c4 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/RoleServiceImpl.java @@ -0,0 +1,49 @@ +package net.gepafin.tendermanagement.service.impl; + +import java.util.List; + +import net.gepafin.tendermanagement.dao.RoleDao; +import net.gepafin.tendermanagement.model.request.RoleReq; +import net.gepafin.tendermanagement.model.response.RoleResponseBean; +import net.gepafin.tendermanagement.service.RoleService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + + +@Service +public class RoleServiceImpl implements RoleService { + + @Autowired + private RoleDao roleDao; + + @Override + @Transactional(rollbackFor = Exception.class) + public RoleResponseBean createRole(RoleReq roleReq) { + return roleDao.createRole(roleReq); + } + @Override + @Transactional(rollbackFor = Exception.class) + public RoleResponseBean updateRole(Long roleId, RoleReq roleReq) { + return roleDao.updateRole(roleId,roleReq); + } + + @Override + @Transactional(readOnly = true) + public RoleResponseBean getRoleById(Long roleId) { + return roleDao.getRoleById(roleId); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public void deleteRole(Long roleId) { + roleDao.deleteById(roleId); + } + + @Override + @Transactional(readOnly = true) + public List getAllRoles() { + return roleDao.getAllRoles(); + + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/service/impl/UserServiceImpl.java b/src/main/java/net/gepafin/tendermanagement/service/impl/UserServiceImpl.java new file mode 100644 index 00000000..c109e6bb --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/service/impl/UserServiceImpl.java @@ -0,0 +1,117 @@ +package net.gepafin.tendermanagement.service.impl; + +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import net.gepafin.tendermanagement.config.SamlSuccessHandler; +import net.gepafin.tendermanagement.dao.UserDao; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.model.request.LoginReq; +import net.gepafin.tendermanagement.model.request.UpdateUserReq; +import net.gepafin.tendermanagement.model.request.UserReq; +import net.gepafin.tendermanagement.enums.RoleStatusEnum; +import net.gepafin.tendermanagement.enums.UserStatusEnum; +import net.gepafin.tendermanagement.model.request.*; +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.service.UserService; +import net.gepafin.tendermanagement.util.Validator; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + + + +@Service +public class UserServiceImpl implements UserService { + + @Autowired + private UserDao userDao; + + @Autowired + private Validator validator; + + @Autowired + private SamlSuccessHandler samlSuccessHandler; + + @Transactional(rollbackFor = Exception.class) + public JWTToken createUser(HttpServletRequest request, String tempToken, UserReq userReq) { + if (tempToken == null) { + validator.validateRequest(request,RoleStatusEnum.ROLE_SUPER_ADMIN); + }else { + samlSuccessHandler.validateToken(tempToken, userReq.getCodiceFiscale()); + } + return userDao.createUser(request, tempToken, userReq); + } + + + @Override + @Transactional(rollbackFor = Exception.class) + public UserResponseBean updateUser(Long userId, UpdateUserReq userReq) { + return userDao.updateUser(userId, userReq); + } + + @Override + @Transactional(readOnly = true) + public UserResponseBean getUserById(Long userId) { + return userDao.getUserById(userId); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public void deleteUser(Long userId) { + userDao.deleteUser(userId); + } + + @Override + public JWTToken login(LoginReq loginReq) { + return userDao.login(loginReq); + + } + + @Override + public UserEntity validateUser(Long userId) { + return userDao.validateUser(userId); + } + + @Override + public String initiatePasswordReset(InitiatePasswordResetReq resetReq) { + return userDao.initiatePasswordReset(resetReq); + } + + @Override + public Boolean resetPassword(ResetPasswordReq resetPasswordReq) { + return userDao.resetPassword(resetPasswordReq); + } + @Override + public Boolean changePassword(ChangePasswordRequest request){ + return userDao.changePassword(request); + } + @Override + public void logoutUser(HttpServletRequest request, HttpServletResponse response) { + userDao.logout(request,response); + } + @Override + @Transactional(rollbackFor = Exception.class) + public UserResponseBean updateUserStatus(Long userId, UserStatusEnum statusReq) { + return userDao.updateUserStatus(userId, statusReq); + + } + @Override + @Transactional(readOnly = true) + public UserResponseBean getValidUser(HttpServletRequest request) { + UserEntity user=validator.validateUser(request); + return userDao.getUserById(user.getId()); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public JWTToken validateExistingUserToken(HttpServletRequest request, String token) { + return userDao.validateExistingUserToken(token); + } + @Override + public UserSamlResponse validateNewUserToken(HttpServletRequest request, String token) { + return userDao.validateNewUserToken(token); + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/util/DateTimeUtil.java b/src/main/java/net/gepafin/tendermanagement/util/DateTimeUtil.java new file mode 100644 index 00000000..ab67ccdd --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/util/DateTimeUtil.java @@ -0,0 +1,53 @@ +package net.gepafin.tendermanagement.util; + +import org.springframework.stereotype.Component; + +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.ZonedDateTime; +import java.util.Calendar; +import java.util.Date; + +@Component +public class DateTimeUtil { + + + public static LocalDateTime DateServerToUTC(LocalDateTime systemDate) { + + ZonedDateTime ldtZoned = systemDate.atZone(ZoneId.systemDefault()); + LocalDateTime localDatetime = ldtZoned.withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(); + return localDatetime; + } + + public static LocalDateTime getPreviousMonthDate(int month) { + Calendar c = Calendar.getInstance(); + c.add(Calendar.MONTH, -month); + LocalDateTime conv = LocalDateTime.ofInstant(c.getTime().toInstant(), ZoneId.systemDefault()); + return conv; + } + + public static Date getDateWithoutTime(LocalDateTime systemDate) { + ZonedDateTime zdt = systemDate.atZone(ZoneId.systemDefault()); + Date date = Date.from(zdt.toInstant()); + Calendar calendar = Calendar.getInstance(); + calendar.setTime(date); + calendar.set(Calendar.HOUR_OF_DAY, 0); + calendar.set(Calendar.MINUTE, 0); + calendar.set(Calendar.SECOND, 0); + calendar.set(Calendar.MILLISECOND, 0); + return calendar.getTime(); + } + + public static LocalDateTime convertDateToLocalDateTime(Date date) { + LocalDateTime ldt = LocalDateTime.ofInstant(date.toInstant(), + ZoneId.systemDefault()); + return ldt; + } + + + public static Date convertLocalDateTimeToDateUsingInstant(LocalDateTime localDateTime) { + return Date + .from(localDateTime.atZone(ZoneId.systemDefault()) + .toInstant()); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/util/FieldValidator.java b/src/main/java/net/gepafin/tendermanagement/util/FieldValidator.java new file mode 100644 index 00000000..26edffff --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/util/FieldValidator.java @@ -0,0 +1,153 @@ +package net.gepafin.tendermanagement.util; + +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.dao.FormDao; +import net.gepafin.tendermanagement.dao.VatCheckDao; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import net.gepafin.tendermanagement.web.rest.api.errors.ValidationException; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.util.CollectionUtils; + +public class FieldValidator { + + private final List errors = new ArrayList<>(); + + public static FieldValidator create() { + return new FieldValidator(); + } + + @Autowired + private VatCheckDao vatCheckDao; + + + public FieldValidator notNull(Object object, String fieldLabel) { + if (Objects.isNull(object)) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.FIELD_NOT_NULL), fieldLabel)); + } + return this; + } + + public FieldValidator notEmpty(List list, String fieldLabel) { + if (list == null || list.isEmpty()) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.FIELD_NOT_EMPTY), fieldLabel)); + } + return this; + } + + public void validate() { + if (!errors.isEmpty()) { + throw new ValidationException(Status.VALIDATION_ERROR, errors, Translator.toLocale(GepafinConstant.VALIDATION_MESSAGE)); + } + } + public FieldValidator minLength(String value, Long minLength, String fieldLabel) { + if (minLength != null && value != null && value.length() < minLength) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_FIELD_MIN_LENGTH), fieldLabel, minLength)); + } + return this; + } + + public FieldValidator maxLength(String value, Long maxLength, String fieldLabel) { + if (maxLength != null && value != null && value.length() > maxLength) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_FIELD_MAX_LENGTH), fieldLabel, maxLength)); + } + return this; + } + + public FieldValidator matchesPattern(String value, String pattern, String fieldLabel) { + if (value != null && pattern != null && !value.matches(pattern)) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_FIELD_PATTERN), fieldLabel)); + } + return this; + } + + public FieldValidator addError( String errorMessage) { + errors.add(errorMessage); + return this; + } + public static boolean isNullOrZero(Long value) { + return value == null || value == 0L; + } + + public FieldValidator validateCustom(String value, String customRule, String fieldId) { + if (customRule == null || value == null) { + return this; // No custom rule to validate + } + + switch (customRule) { + + case GepafinConstant.IS_PIVA: + // VAT number: max 11 digits, can start with 0 + if (!value.matches("^\\d{1,11}$")) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_PIVA), fieldId, customRule)); + } + break; + case GepafinConstant.IS_CODICE_FISCALE: + // 16 characters: 6 letters, 2 digits, 1 letter, 2 digits, 1 letter, 3 digits, 1 letter + if (!value.matches("^[A-Z]{6}[0-9]{2}[A-Z]{1}[0-9]{2}[A-Z]{1}[0-9]{3}[A-Z]{1}$")) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_CODICE_FISCALE), fieldId, customRule)); + } + break; + + case GepafinConstant.IS_CAP: + // 5 digits (can start with 0) + if (!value.matches("^[0-9]{5}$")) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_CAP), fieldId, customRule)); + } + break; + + case GepafinConstant.IS_IBAN: + // IBAN must be 27 characters + if (value.length() != 27) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_IBAN), fieldId, customRule)); + } + break; + + case GepafinConstant.IS_EMAIL: + case GepafinConstant.IS_EMAIL_PEC: + // Email validation (using a simple regex for email) + if (!value.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$")) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_EMAIL), fieldId, customRule)); + } + break; + + case GepafinConstant.IS_URL: + // URL validation (simple regex for URL) + if (!value.matches("^(https?|ftp)://[^\s/$.?#].[^\s]*$")) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_URL), fieldId, customRule)); + } + break; + + case GepafinConstant.IS_MARCA_DA_BOLLO: + // Length must be 14 digits (can start with 0) + if (!value.matches("^[0-9]{14}$")) { + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_MARCA_DA_BOLLO), fieldId, customRule)); + } + break; + + default: + // If the custom rule is unknown, just log or add an error (optional) + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.VALIDATION_FIELD_CUSTOM), fieldId, customRule)); + break; + } + + return this; + } + public FieldValidator isRequired(String value,Boolean isRequired, String fieldName) { + if (Boolean.TRUE.equals(isRequired)) { // Only check if isRequired is true + if (Objects.isNull(value) || value.isEmpty()) { // Check if value is null or empty + errors.add(MessageFormat.format(Translator.toLocale(GepafinConstant.FIELD_NOT_NULL), fieldName)); + } + } + return this; + } + public boolean hasErrors() { + return !errors.isEmpty(); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/util/Utils.java b/src/main/java/net/gepafin/tendermanagement/util/Utils.java new file mode 100644 index 00000000..9de26d9c --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/util/Utils.java @@ -0,0 +1,193 @@ +package net.gepafin.tendermanagement.util; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.json.JsonReadFeature; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.type.TypeFactory; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import io.micrometer.common.util.StringUtils; +import org.apache.commons.collections4.MapUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.reflect.Field; +import java.lang.reflect.Type; +import java.nio.charset.StandardCharsets; +import java.security.SecureRandom; +import java.util.Base64; +import java.util.List; +import java.util.Map; +import java.util.function.Consumer; +import java.util.function.Supplier; +import java.util.stream.Collectors; + + +public class Utils { + + public static final Logger log = LoggerFactory.getLogger(Utils.class); + + private static final ObjectMapper mapper = new ObjectMapper() + .registerModule(new JavaTimeModule()) + .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + + public static U convertObject(T source, Class destinationClass) { + try { + return mapper.convertValue(source, destinationClass); + } catch (Exception e) { + log.error("Error converting object: " + e.getMessage(), e); + } + return null; + } + + public static List convertSourceListToDestinationList(List sourceList, Class destinationClass) { + try { + return sourceList.stream() + .map(source -> mapper.convertValue(source, destinationClass)) + .collect(Collectors.toList()); + } catch (Exception e) { + log.error("Error converting list: " + e.getMessage(), e); + } + return null; + } + + public static List convertSourceToList(T source, Class destinationClass) { + try { + // Convert single source object to a single-element list of destination type + return List.of(mapper.convertValue(source, destinationClass)); + } catch (Exception e) { + log.error("Error converting single object to list: " + e.getMessage(), e); + } + return null; + } + public static String extractFileName(String filePath) { + if (filePath == null || filePath.isEmpty()) { + return null; + } + int lastSlashIndex = filePath.lastIndexOf('/'); + + if (lastSlashIndex >= 0 && lastSlashIndex < filePath.length() - 1) { + return filePath.substring(lastSlashIndex + 1); + } else { + return filePath; + } + } + public static String decodeBase64String(String decodedString) { + if (StringUtils.isBlank(decodedString)) { + return decodedString; + } + byte[] decode = Base64.getDecoder().decode(decodedString.getBytes(StandardCharsets.UTF_8)); + return new String(decode, StandardCharsets.UTF_8); + } + + public static void setIfNotNull(Consumer setter, T value) { + if (value != null) { + setter.accept(value); + } + } + public static void setIfUpdated(Supplier getter, Consumer setter, T newValue) { + T currentValue = getter.get(); + if (newValue != null && !newValue.equals(currentValue)) { + setter.accept(newValue); + } + } + public static String convertListToJsonString(List list) { + try { + return mapper.writeValueAsString(list); + } catch (JsonProcessingException e) { + e.printStackTrace(); + // Handle exception or throw a custom exception + return null; + } + } + public static List convertJsonStringToList(String jsonString, Class clazz) { + try { + TypeReference> typeRef = new TypeReference>() { + @Override + public Type getType() { + return TypeFactory.defaultInstance().constructCollectionType(List.class, clazz); + } + }; + return mapper.readValue(jsonString, typeRef); + } catch (Exception e) { + e.printStackTrace(); + // Handle the exception appropriately (e.g., throw a custom exception) + return null; + } + } + public static String convertMapIntoJsonString(Map map) { + try { + ObjectMapper mapper = new ObjectMapper(); + if (MapUtils.isNotEmpty(map)) { + return mapper.writeValueAsString(map); + } + } catch (JsonProcessingException e) { + log.error(e.getMessage()); + } + return null; + } + public static Map convertIntoJson(String jsonString) { + if (jsonString != null && !jsonString.isEmpty()) { + try { + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature(), true); + return mapper.readValue(jsonString, Map.class); + } catch (Exception e) { + log.error(e.getMessage()); + } + } + return null; + } + public static U convertSourceObjectToDestinationObject(T source, Class destinationClass) { + try { + mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); + mapper.registerModule(new JavaTimeModule()); + return mapper.convertValue(source, destinationClass); + } catch (Exception e) { + log.error("Error converting object: " + e.getMessage(), e); + } + return null; + } + public static void retainOnlySpecificFields(T requestObject, List retainFields) throws IllegalAccessException { + // Get all declared fields of the request object's class + Field[] fields = requestObject.getClass().getDeclaredFields(); + + for (Field field : fields) { + field.setAccessible(true); // To allow access to private fields + + // Check if the field is in the retainFields list + if (!retainFields.contains(field.getName())) { + field.set(requestObject, null); // Set the field to null if not in the retain list + } + } + } + + public static String encodeData(String data) { + return Base64.getEncoder().encodeToString(data.getBytes(StandardCharsets.UTF_8)); + } + + public static String decodeData(String token) { + byte[] decodedBytes = Base64.getDecoder().decode(token); + return new String(decodedBytes, StandardCharsets.UTF_8); + } + + public static String generateSecureToken() { + SecureRandom secureRandom = new SecureRandom(); + byte[] tokenBytes = new byte[24]; + secureRandom.nextBytes(tokenBytes); + String token = Base64.getUrlEncoder().withoutPadding().encodeToString(tokenBytes); + log.debug("Generated secure token: {}", token); + return token; + } + + public static Map> convertStringIntoMap(String jsonString) { + try { + return mapper.readValue(jsonString, new TypeReference>>() { + }); + } catch (Exception e) { + log.error("Error converting object: " + e.getMessage(), e); + return null; + } + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/util/Validator.java b/src/main/java/net/gepafin/tendermanagement/util/Validator.java new file mode 100644 index 00000000..f4f53d0b --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/util/Validator.java @@ -0,0 +1,59 @@ +package net.gepafin.tendermanagement.util; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.config.jwt.TokenProvider; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.enums.RoleStatusEnum; +import net.gepafin.tendermanagement.service.UserService; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import net.gepafin.tendermanagement.web.rest.api.errors.UnauthorizedAccessException; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.GrantedAuthority; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.stereotype.Component; + +import java.util.Map; + +@Component +public class Validator { + + @Autowired + private TokenProvider tokenProvider; + + @Autowired + private UserService userService; + + public Map getUserInfoFromToken(HttpServletRequest request) { + return tokenProvider.getUserInfoAndUserIdFromToken(request); + } + + public UserEntity validateUser(HttpServletRequest request) { + Map userInfo= tokenProvider.getUserInfoAndUserIdFromToken(request); + return userService.validateUser(Long.parseLong(userInfo.get("userId").toString())); + } + + public Boolean checkIsSuperAdmin(HttpServletRequest request) { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + + if (authentication != null && authentication.isAuthenticated()) { + // Check if the user has the ROLE_SUPER_ADMIN authority + for (GrantedAuthority authority : authentication.getAuthorities()) { + if (RoleStatusEnum.ROLE_SUPER_ADMIN.getValue().equals(authority.getAuthority())) { + return true; + } + } + } + return false; + } + + public void validateRequest(HttpServletRequest request,RoleStatusEnum role) { + if (RoleStatusEnum.ROLE_SUPER_ADMIN.equals(role) && Boolean.FALSE.equals(checkIsSuperAdmin(request))) { + throw new UnauthorizedAccessException(Status.UNAUTHORIZED, Translator.toLocale(GepafinConstant.INVALID_USER)); + } + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/ApplicationApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/ApplicationApi.java new file mode 100644 index 00000000..9499bfe0 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/ApplicationApi.java @@ -0,0 +1,134 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import java.util.List; + +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.model.request.ApplicationRequest; +import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum; +import net.gepafin.tendermanagement.enums.FormActionEnum; +import net.gepafin.tendermanagement.model.request.ApplicationRequestBean; +import net.gepafin.tendermanagement.model.response.ApplicationGetResponseBean; +import net.gepafin.tendermanagement.model.response.ApplicationResponse; +import net.gepafin.tendermanagement.model.response.ApplicationResponseBean; +import net.gepafin.tendermanagement.model.response.NextOrPreviousFormResponse; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; + +@Validated +public interface ApplicationApi { + + @Operation(summary = "Api to create or update application form", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/{applicationId}", + produces = { "application/json" }) + ResponseEntity> createApplication(HttpServletRequest request, + @Parameter(description = " Flow request object", required = true) @Valid @RequestBody ApplicationRequestBean applicationRequestBean, + @Parameter(description = "The application id", required = true) @PathVariable(value = "applicationId", required = true) Long applicationId, + @Parameter(description = "The form ID", required = true) @RequestParam("formId") Long formId); + + @Operation(summary = "Api to get an application by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{applicationId}", produces = "application/json") + ResponseEntity> getApplicationByFormId(HttpServletRequest request, @Parameter(description = "The application id", required = true) @PathVariable(value = "applicationId", required = true) Long applicationId,@Parameter(description = "The form id", required = false) @RequestParam(value = "formId",required = false) Long formId); + + @Operation(summary = "Api to get all applications", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "", produces = "application/json") + ResponseEntity>> getAllApplications(HttpServletRequest request, + @Parameter(description = "The call id", required = false) @RequestParam(value = "callId", required = false) Long callId); + + @Operation(summary = "Api to delete application", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @DeleteMapping(value = "/{applicationId}") + ResponseEntity> deleteApplication(HttpServletRequest request, + @Parameter(description = "The application id", required = true) @PathVariable("applicationId") Long applicationId); + + @Operation(summary = "Api to create application", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PostMapping(value = "/call/{callId}", + produces = { "application/json" }) + ResponseEntity> createApplicationByCallId(HttpServletRequest request, + @Parameter(description = " Flow request object", required = true) @Valid @RequestBody ApplicationRequest applicationRequest, + @Parameter(description = "The call ID", required = true) @PathVariable("callId") Long callId); + + + + @Operation(summary = "Api to get an next or previous form by current form id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{applicationId}/form/next-previous", produces = "application/json") + ResponseEntity> getNextOrPreviousForm(HttpServletRequest request, + @Parameter(description = "The applicaltion id", required = true) @PathVariable("applicationId") Long applicationId, + @Parameter(description = "The form id", required = false) @RequestParam(value = "formId", required = false) Long formId, + @RequestParam(value = "action", required = false) FormActionEnum action); + + + @Operation(summary = "Api to update application status", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/{applicationId}/status", produces = { "application/json" }) + ResponseEntity> updateApplicationStatus(HttpServletRequest request, + @Parameter(description = "The application id", required = true) @PathVariable("applicationId") Long applicationId, + @Parameter(description = "status", required = true)@RequestParam(value = "status", required = true) ApplicationStatusTypeEnum status); + + +} + diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/CallApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/CallApi.java new file mode 100644 index 00000000..cc7f985a --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/CallApi.java @@ -0,0 +1,137 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import java.util.List; + +import net.gepafin.tendermanagement.enums.CallStatusEnum; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep1; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep2; +import net.gepafin.tendermanagement.model.request.UpdateCallRequestStep1; +import net.gepafin.tendermanagement.model.response.CallDetailsResponseBean; +import net.gepafin.tendermanagement.model.response.CallResponse; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; + +@Validated +public interface CallApi { + + @Operation(summary = "Api to create call step 1", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PostMapping(value = "/step1", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + public ResponseEntity> createCallStep1(HttpServletRequest request, + @Parameter(description = "Call request object", required = true) + @Valid @RequestBody CreateCallRequestStep1 createCallRequest); + + @Operation(summary = "Api to update call step 2", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PutMapping(value = "/step2/{callId}", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + public ResponseEntity> createCallStep2(HttpServletRequest request, + @Parameter(description = "The call id", required = true) @PathVariable("callId") Long callId, + @Parameter(description = "Call request object", required = true) @Valid @RequestBody CreateCallRequestStep2 createCallRequest); + + @Operation(summary = "Api to update call step 1", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PutMapping(value = "/step1/{callId}", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + public ResponseEntity> updateCallStep1(HttpServletRequest request, + @Parameter(description = "The call id", required = true) @PathVariable("callId") Long callId, + @Parameter(description = "Call request object", required = true) @Valid @RequestBody UpdateCallRequestStep1 updateCallRequest); + @Operation(summary = "Api to get call by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{callId}", + produces = { "application/json" }) + ResponseEntity> getCallById( + @Parameter(description = "The call ID", required = true) @PathVariable("callId") Long callId); + + + @Operation(summary = "Api to get all calls", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "", + produces = { "application/json" }) + ResponseEntity>> getAllCalls(HttpServletRequest request); + + + @Operation(summary = "Api to validate call", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PostMapping(value = "/validate/{callId}", produces = MediaType.APPLICATION_JSON_VALUE) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + public ResponseEntity> validateCallData(HttpServletRequest request, + @Parameter(description = "The call id", required = true) @PathVariable("callId") Long callId); + @Operation(summary = "Api to update call status", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)})) + }) + @RequestMapping(value = "/{callId}/status", + produces = {"application/json"}, + method = RequestMethod.PUT) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + public ResponseEntity> updateCallStatus(HttpServletRequest request, + @Parameter(description = "The call id", required = true) @PathVariable("callId") Long callId, + @Parameter(description = "status", required = true)@RequestParam(value = "status", required = true) CallStatusEnum status); +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/DocumentApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/DocumentApi.java new file mode 100644 index 00000000..9c2cedcc --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/DocumentApi.java @@ -0,0 +1,79 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum; +import net.gepafin.tendermanagement.enums.DocumentTypeEnum; +import net.gepafin.tendermanagement.model.response.DocumentResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; + +import java.util.List; + +public interface DocumentApi { + + @Operation(summary = "Api to upload a file", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) }))}) + @PostMapping(value = "/uploadFile/source/{sourceId}", consumes = MediaType.MULTIPART_FORM_DATA_VALUE) + default ResponseEntity>> uploadFile(HttpServletRequest httpServletRequest, @Parameter(description = "Source Id", required = true) @PathVariable("sourceId") Long sourceId, @RequestParam DocumentSourceTypeEnum sourceType, @RequestParam("file") List files, @RequestParam("documentType") DocumentTypeEnum documentTypeEnum) { + return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED); + } + + @Operation(summary = "API to delete a file by document id", + responses = { + @ApiResponse(responseCode = "200", description = "File deleted successfully"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @DeleteMapping(value = "/deleteFile") + default ResponseEntity> deleteFile(HttpServletRequest httpServletRequest, + @RequestParam( "id") Long id) { + return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED); + } + @Operation(summary = "Api to update document", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) }))}) + @PutMapping(value = "/{id}", consumes = MediaType.MULTIPART_FORM_DATA_VALUE) + default ResponseEntity> updateDocument(HttpServletRequest httpServletRequest, @Parameter(description = "document id", required = true) @PathVariable("id") Long documentId, @RequestParam("file") MultipartFile file, @RequestParam("documentType") DocumentTypeEnum documentTypeEnum) { + return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED); + } + @Operation(summary = "API to get document by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })) + }) + @GetMapping(value = "/{id}", produces = MediaType.APPLICATION_JSON_VALUE) + ResponseEntity> getDocumentById(HttpServletRequest request, + @Parameter(description = "document id", required = true) + @PathVariable("id") Long id); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/EvaluationCriteriaApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/EvaluationCriteriaApi.java new file mode 100644 index 00000000..4274cccb --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/EvaluationCriteriaApi.java @@ -0,0 +1,78 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.model.request.EvaluationCriteriaRequest; +import net.gepafin.tendermanagement.model.response.EvaluationCriteriaResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +public interface EvaluationCriteriaApi { + + + @Operation(summary = "Api to create evaluation criteria", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PostMapping(value = "", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + ResponseEntity> createEvaluationCriteria(HttpServletRequest request, + @Parameter(description = "Evaluation criteria request object", required = true) + @Valid @RequestBody EvaluationCriteriaRequest createCallRequest); + + @Operation(summary = "Api to get evaluation criteria by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })) + }) + @GetMapping(value = "/{id}", produces = MediaType.APPLICATION_JSON_VALUE) + ResponseEntity> getEvaluationCriteriaById(HttpServletRequest request, + @Parameter(description = "evaluation criteria id", required = true) + @PathVariable("id") Long id); + + @Operation(summary = "API to update evaluation criteria", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PutMapping(value = "/{id}", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + ResponseEntity> updateEvaluationCriteria(HttpServletRequest request, + @Parameter(description = "evaluation criteria id", required = true) + @PathVariable("id") Long id, + @Parameter(description = "Evaluation criteria request object", required = true) + @Valid @RequestBody EvaluationCriteriaRequest evaluationCriteriaRequest); + + @Operation(summary = "API to delete evaluation criteria", + responses = { + @ApiResponse(responseCode = "204", description = "No Content"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })) + }) + @DeleteMapping(value = "/{id}", produces = MediaType.APPLICATION_JSON_VALUE) + ResponseEntity deleteEvaluationCriteria(HttpServletRequest request, + @Parameter(description = "evaluation criteria id", required = true) + @PathVariable("id") Long id); +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/FaqApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FaqApi.java new file mode 100644 index 00000000..f44491a8 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FaqApi.java @@ -0,0 +1,57 @@ +package net.gepafin.tendermanagement.web.rest.api; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import net.gepafin.tendermanagement.model.request.FaqReq; +import net.gepafin.tendermanagement.model.response.FaqResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import jakarta.servlet.http.HttpServletRequest; +import javax.validation.Valid; + +public interface FaqApi { + + @Operation(summary = "API to create FAQ", + responses = { + @ApiResponse(responseCode = "201", description = "Created"), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = "application/json", examples = @ExampleObject(value = "{ \"error\": \"Bad Request\" }"))), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = "application/json", examples = @ExampleObject(value = "{ \"error\": \"Unauthorized\" }"))), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = "application/json", examples = @ExampleObject(value = "{ \"error\": \"Not Found\" }"))) + }) + @PostMapping(value = "/call/{callId}", consumes = "application/json", produces = "application/json") + ResponseEntity> createFaq(HttpServletRequest request, @Parameter(description = "call id", required = true) + @PathVariable("callId") Long callId, @Valid @RequestBody FaqReq faqRequest); + + @Operation(summary = "API to get FAQ by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = "application/json", examples = @ExampleObject(value = "{ \"error\": \"Not Found\" }"))) + }) + @GetMapping(value = "/{id}", produces = "application/json") + ResponseEntity> getFaqById(HttpServletRequest request, + @PathVariable("id") Long id); + + @Operation(summary = "API to update FAQ", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = "application/json", examples = @ExampleObject(value = "{ \"error\": \"Not Found\" }"))), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = "application/json", examples = @ExampleObject(value = "{ \"error\": \"Bad Request\" }"))) + }) + @PutMapping(value = "/{id}", consumes = "application/json", produces = "application/json") + ResponseEntity> updateFaq(HttpServletRequest request, + @PathVariable("id") Long id, + @Valid @RequestBody FaqReq faqRequest); + + @Operation(summary = "API to delete FAQ", + responses = { + @ApiResponse(responseCode = "204", description = "No Content"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = "application/json", examples = @ExampleObject(value = "{ \"error\": \"Not Found\" }"))) + }) + @DeleteMapping(value = "/{id}") + ResponseEntity> deleteFaq(HttpServletRequest request, + @PathVariable("id") Long id); +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/FlowApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FlowApi.java new file mode 100644 index 00000000..218ed5ff --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FlowApi.java @@ -0,0 +1,55 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.model.request.FlowRequestBean; +import net.gepafin.tendermanagement.model.response.FlowResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + + +@Validated +public interface FlowApi { + + @Operation(summary = "Api to create or update flow", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/call/{callId}", + produces = { "application/json" }) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + ResponseEntity> createOrUpdateFlow(HttpServletRequest request, + @Parameter(description = " Flow request object", required = true) @Valid @RequestBody FlowRequestBean flowRequestBean, + @Parameter(description = "The call ID", required = true) @PathVariable("callId") Long callId); + + @Operation(summary = "Api to get flow by callId", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/call/{callId}", + produces = { "application/json" }) + ResponseEntity> getFlowByCallId(HttpServletRequest request, + @Parameter(description = "The call ID", required = true) @PathVariable("callId") Long callId); + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormApi.java new file mode 100644 index 00000000..99eb8835 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormApi.java @@ -0,0 +1,100 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.model.request.FormRequest; +import net.gepafin.tendermanagement.model.response.FormResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + + +public interface FormApi { + + @Operation(summary = "Api to create form", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PostMapping(value = "/call/{callId}", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + public ResponseEntity> createForm(HttpServletRequest request,@Parameter(description = "The call ID", required = true) @PathVariable("callId") Long callId, + @Parameter(description = "form request object", required = true) + @Valid @RequestBody FormRequest formRequest); + + + @Operation(summary = "Api to update form", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/{formId}", + produces = { "application/json" }) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + ResponseEntity> updateForm(HttpServletRequest request, + @Parameter(description = "The form ID", required = true) @PathVariable("formId") Long formId, + @Parameter(description = "form request object", required = true) @Valid @RequestBody FormRequest formRequest,@Parameter(description = "force delete flow ",required = true)@RequestParam(value = "forceDeleteFlow",required = true)Boolean forceDeleteFlow); + + @Operation(summary = "Api to get form by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{formId}", + produces = { "application/json" }) + ResponseEntity> getFormById(HttpServletRequest request, + @Parameter(description = "The form ID", required = true) @PathVariable("formId") Long formId); + + + @Operation(summary = "Api to delete form", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @DeleteMapping(value = "/{formId}") + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + ResponseEntity> deleteForm(HttpServletRequest request, + @Parameter(description = "The form ID", required = true) @PathVariable("formId") Long formId); + + @Operation(summary = "Api to get forms by callId", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/call/{callId}", + produces = { "application/json" }) + ResponseEntity>> getFormsByCallId(HttpServletRequest request, + @Parameter(description = "The call ID", required = true) @PathVariable("callId") Long callId); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormFieldApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormFieldApi.java new file mode 100644 index 00000000..0aeecf0f --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormFieldApi.java @@ -0,0 +1,100 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.model.request.FormFieldRequest; +import net.gepafin.tendermanagement.model.response.FormFieldResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +public interface FormFieldApi { + + @Operation(summary = "Api to create form field", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PostMapping(value = "", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + public ResponseEntity> createFormField(HttpServletRequest request, + @Parameter(description = "form field request object", required = true) + @Valid @RequestBody FormFieldRequest formFieldRequest); + + + @Operation(summary = "Api to update form field", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/{formFieldId}", + produces = { "application/json" }) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + ResponseEntity> updateFormField(HttpServletRequest request, + @Parameter(description = "The form field ID", required = true) @PathVariable("formFieldId") Long formFieldId, + @Parameter(description = "form field request object", required = true) @Valid @RequestBody FormFieldRequest formFieldRequest); + + @Operation(summary = "Api to get form field by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{formFieldId}", + produces = { "application/json" }) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + ResponseEntity> getFormFieldById(HttpServletRequest request, + @Parameter(description = "The form field ID", required = true) @PathVariable("formFieldId") Long formFieldId); + + + @Operation(summary = "Api to delete form field", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @DeleteMapping(value = "/{formFieldId}") + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + ResponseEntity> deleteForm(HttpServletRequest request, + @Parameter(description = "The form field ID", required = true) @PathVariable("formFieldId") Long formFieldId); + + @Operation(summary = "Api to get all form field", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "", + produces = { "application/json" }) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + ResponseEntity>> getAllFormField(HttpServletRequest request); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormTemplateApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormTemplateApi.java new file mode 100644 index 00000000..7b3db788 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/FormTemplateApi.java @@ -0,0 +1,94 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.model.request.FormTemplateRequest; +import net.gepafin.tendermanagement.model.response.FormTemplateResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +public interface FormTemplateApi { + + @Operation(summary = "Api to create form template", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) + }) + @PostMapping(value = "", produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity> createFormTemplate(HttpServletRequest request, + @Parameter(description = "form template request object", required = true) + @Valid @RequestBody FormTemplateRequest formTemplateRequest); + + + @Operation(summary = "Api to update form template", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/{formTemplateId}", + produces = { "application/json" }) + ResponseEntity> updateFormTemplate(HttpServletRequest request, + @Parameter(description = "The form template ID", required = true) @PathVariable("formTemplateId") Long formTemplateId, + @Parameter(description = "form template request object", required = true) @Valid @RequestBody FormTemplateRequest formTemplateRequest); + + @Operation(summary = "Api to get form template by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{formTemplateId}", + produces = { "application/json" }) + ResponseEntity> getFormTemplateById(HttpServletRequest request, + @Parameter(description = "The form template ID", required = true) @PathVariable("formTemplateId") Long formTemplateId); + + + @Operation(summary = "Api to delete form template", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @DeleteMapping(value = "/{formTemplateId}") + ResponseEntity> deleteFormTemplate(HttpServletRequest request, + @Parameter(description = "The form template ID", required = true) @PathVariable("formTemplateId") Long formTemplateId); + + @Operation(summary = "Api to get all form template", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "", + produces = { "application/json" }) + ResponseEntity>> getAllFormTemplate(HttpServletRequest request); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/LookUpDataApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/LookUpDataApi.java new file mode 100644 index 00000000..d4044016 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/LookUpDataApi.java @@ -0,0 +1,81 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum; +import net.gepafin.tendermanagement.model.request.LookUpDataRequest; +import net.gepafin.tendermanagement.model.response.LookUpDataResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import jakarta.servlet.http.HttpServletRequest; +import javax.validation.Valid; +import java.util.List; + +public interface LookUpDataApi { + + @Operation(summary = "Api to create LookUp Data", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @PostMapping(value = "", consumes = "application/json", produces = "application/json") + ResponseEntity> createLookUpData(HttpServletRequest request, @Valid @RequestBody LookUpDataRequest lookUpDataReq); + + @Operation(summary = "Api to get LookUp Data by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @GetMapping(value = "/{id}", produces = "application/json") + ResponseEntity> getLookUpDataById(HttpServletRequest request, @PathVariable("id") Long id); + + @Operation(summary = "Api to update LookUp Data", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @PutMapping(value = "/{id}", consumes = "application/json", produces = "application/json") + ResponseEntity> updateLookUpData(HttpServletRequest request, @PathVariable("id") Long id, @Valid @RequestBody LookUpDataRequest lookUpDataReq); + + @Operation(summary = "Api to delete LookUp Data", + responses = { + @ApiResponse(responseCode = "204", description = "No Content"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @DeleteMapping(value = "/{id}") + ResponseEntity> deleteLookUpData(HttpServletRequest request, @PathVariable("id") Long id); + + @Operation(summary = "Api to get LookUp Data by type", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @GetMapping(value = "/type", produces = "application/json") + ResponseEntity>> getLookUpDataByType(HttpServletRequest request, @RequestParam("type") List types); +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/RegionApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/RegionApi.java new file mode 100644 index 00000000..3876250f --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/RegionApi.java @@ -0,0 +1,88 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import net.gepafin.tendermanagement.model.request.RegionReq; +import net.gepafin.tendermanagement.model.response.RegionResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.Parameter; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@Validated +@RequestMapping("/region") +public interface RegionApi { + + @Operation(summary = "Api to create region", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PostMapping(value = "",produces = "application/json") + ResponseEntity> createRegion( + @Parameter(description = "Region request object", required = true) @Valid @RequestBody RegionReq regionReq); + + @Operation(summary = "Api to update region", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/{regionId}", produces = "application/json") + ResponseEntity> updateRegion( + @Parameter(description = "The region id", required = true) @PathVariable("regionId") Long regionId, + @Parameter(description = "Region request object", required = true) @Valid @RequestBody RegionReq regionReq); + + @Operation(summary = "Api to get a region by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{regionId}", produces = "application/json") + ResponseEntity> getRegionById( + @Parameter(description = "The region id", required = true) @PathVariable("regionId") Long regionId); + + @Operation(summary = "Api to get all regions", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "", + produces = { "application/json" }) + ResponseEntity>> getAllRegions(); + @Operation(summary = "Api to delete region", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @DeleteMapping(value = "/{regionId}") + ResponseEntity> deleteRegion( + @Parameter(description = "The region id", required = true) @PathVariable("regionId") Long regionId); +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/RoleApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/RoleApi.java new file mode 100644 index 00000000..fbee0b1e --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/RoleApi.java @@ -0,0 +1,92 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import net.gepafin.tendermanagement.model.request.RoleReq; +import net.gepafin.tendermanagement.model.response.RoleResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.Parameter; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@Validated +public interface RoleApi { + + @Operation(summary = "Api to create role", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PostMapping(value = "", + produces = { "application/json" }) + ResponseEntity> createRole( + @Parameter(description = " Role request object", required = true) @Valid @RequestBody RoleReq roleReq); + + + @Operation(summary = "Api to update role", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @PutMapping(value = "/{roleId}", + produces = { "application/json" }) + ResponseEntity> updateRole( + @Parameter(description = "The role ID", required = true) @PathVariable("roleId") Long roleId, + @Parameter(description = "Role request object", required = true) @Valid @RequestBody RoleReq roleReq); + + @Operation(summary = "Api to get role by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/{roleId}", + produces = { "application/json" }) + ResponseEntity> getRoleById( + @Parameter(description = "The role ID", required = true) @PathVariable("roleId") Long roleId); + + @Operation(summary = "Api to get all roles", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "", + produces = { "application/json" }) + ResponseEntity>> getAllRoles(); + + @Operation(summary = "Api to delete role", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @DeleteMapping(value = "/{roleId}") + ResponseEntity> deleteRole( + @Parameter(description = "The role ID", required = true) @PathVariable("roleId") Long roleId); +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/SamlApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/SamlApi.java new file mode 100644 index 00000000..54ac52dd --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/SamlApi.java @@ -0,0 +1,30 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; + +public interface SamlApi { + + + @Operation(summary = "Api to get SP metadata", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/gw/metadata", + produces = { "application/json" }) + ResponseEntity getMetadata(HttpServletRequest request); + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/UserApi.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/UserApi.java new file mode 100644 index 00000000..18281f96 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/UserApi.java @@ -0,0 +1,226 @@ +package net.gepafin.tendermanagement.web.rest.api; + +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.ExampleObject; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.enums.UserStatusEnum; +import net.gepafin.tendermanagement.model.request.*; +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.model.util.Response; +import net.gepafin.tendermanagement.web.rest.api.errors.ErrorConstants; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + + +@Validated +public interface UserApi { + + @Operation(summary = "Api to create user", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "", + produces = {"application/json"}, + method = RequestMethod.POST) +// @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + default ResponseEntity> createUser(HttpServletRequest request, + @Parameter(description = "temp spid Token", required = false) @RequestParam(value = "tempToken", required = false) String tempToken, + @Parameter(description = "User request object", required = true) @Validated @RequestBody UserReq userReq) { + return new ResponseEntity>(HttpStatus.NOT_IMPLEMENTED); + } + + @Operation(summary = "Api to update user", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "/{userId}", + produces = {"application/json"}, + method = RequestMethod.PUT) + default ResponseEntity> updateUser( + @Parameter(description = "The user id", required = true) @PathVariable("userId") Long userId, + @Parameter(description = "User request object", required = true) @Valid @RequestBody UpdateUserReq userReq) { + return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED); + } + + @Operation(summary = "Api to get user by id", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "/{userId}", + produces = {"application/json"}, + method = RequestMethod.GET) + default ResponseEntity> getUserById( + @Parameter(description = "The user id", required = true) @PathVariable("userId") Long userId) { + return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED); + } + + @Operation(summary = "Api to delete user", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "/{userId}", + method = RequestMethod.DELETE) + default ResponseEntity> deleteUser( + @Parameter(description = "The user id", required = true) @PathVariable("userId") Long userId) { + return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED); + } + + @Operation(summary = "Api to login user", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "400", description = "Bad Request"), + @ApiResponse(responseCode = "401", description = "Unauthorized")}) + @RequestMapping(value = "/login", + produces = {"application/json"}, + method = RequestMethod.POST) + ResponseEntity> login( + @Parameter(description = "Login request object", required = true) @Valid @RequestBody LoginReq loginReq); + @Operation(summary = "Api to initiate password reset request", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "/reset-password/initiate", + produces = {"application/json"}, + method = RequestMethod.POST) + ResponseEntity> initiatePasswordReset( + @Parameter(description = "Initiate password reset request object", required = true) @Valid @RequestBody InitiatePasswordResetReq initiatePasswordResetReq); + + @Operation(summary = "Api to reset password", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "/reset-password", + produces = {"application/json"}, + method = RequestMethod.POST) + ResponseEntity> resetPassword( + @Parameter(description = "Reset password request object", required = true) @Valid @RequestBody ResetPasswordReq resetPasswordReq); + @Operation(summary = "Api to change user password", + responses = { + @ApiResponse(responseCode = "200", description = "Password Changed Successfully", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = "{ \"message\": \"Password changed successfully.\" }")})), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "/change-password", + produces = {"application/json"}, + method = RequestMethod.POST) + ResponseEntity> changePassword( + @Parameter(description = "Change password request object", required = true) @Valid @RequestBody ChangePasswordRequest changePasswordRequest); @Operation(summary = "Api to logout user", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)}))}) + @RequestMapping(value = "/logout", + method = RequestMethod.POST) + ResponseEntity> logoutUser( + @Parameter(description = "The request object is not needed for logout", required = false) HttpServletRequest request, + @Parameter(description = "The response object is not needed for logout", required = false) HttpServletResponse response); + @Operation(summary = "Api to update user active/deactive status", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE)})), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE)})) + }) + @RequestMapping(value = "/{userId}/status", + produces = {"application/json"}, + method = RequestMethod.PUT) + @PreAuthorize("hasRole('ROLE_SUPER_ADMIN')") + default ResponseEntity> updateUserStatus( + @Parameter(description = "The user id", required = true) @PathVariable("userId") Long userId, + @Parameter(description = "status", required = true)@RequestParam(value = "status", required = true) UserStatusEnum status) { + return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED); + } + + @Operation(summary = "Api to get valid user from token", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/me", + produces = { "application/json" }) + ResponseEntity> getValidUser(HttpServletRequest request); + + @Operation(summary = "Api to validate existing user from saml token", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/sso/validate/existing-user/{token}", + produces = { "application/json" }) + ResponseEntity> validateExistingUserToken(HttpServletRequest request, + @Parameter(description = "The spid token", required = true) @PathVariable("token") String token); + + + @Operation(summary = "Api to validate new user from saml token", + responses = { + @ApiResponse(responseCode = "200", description = "OK"), + @ApiResponse(responseCode = "404", description = "Not Found", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.NOTFOUND_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.UNAUTHORIZED_ERROR_EXAMPLE) })), + @ApiResponse(responseCode = "400", description = "Bad Request", content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE, examples = { + @ExampleObject(value = ErrorConstants.BADREQUEST_ERROR_EXAMPLE) })) }) + @GetMapping(value = "/sso/validate/new-user/{token}", + produces = { "application/json" }) + ResponseEntity> validateNewUserToken(HttpServletRequest request, + @Parameter(description = "The spid token", required = true) @PathVariable("token") String token); + + + + +} + diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/BadRequestAlertException.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/BadRequestAlertException.java new file mode 100644 index 00000000..c8e6abc9 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/BadRequestAlertException.java @@ -0,0 +1,28 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +import org.zalando.problem.AbstractThrowableProblem; +import org.zalando.problem.Status; + +import java.net.URI; +import java.util.HashMap; +import java.util.Map; + +public class BadRequestAlertException extends AbstractThrowableProblem { + + private static final long serialVersionUID = 1L; + + public BadRequestAlertException(String defaultMessage, String entityName, String errorKey) { + this(ErrorConstants.DEFAULT_TYPE, defaultMessage, entityName, errorKey); + } + + public BadRequestAlertException(URI type, String defaultMessage, String entityName, String errorKey) { + super(type, defaultMessage, Status.BAD_REQUEST, null, null, null, getAlertParameters(entityName, errorKey)); + } + + private static Map getAlertParameters(String entityName, String errorKey) { + Map parameters = new HashMap<>(); + parameters.put("message", "error." + errorKey); + parameters.put("params", entityName); + return parameters; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/CustomValidationException.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/CustomValidationException.java new file mode 100644 index 00000000..197a4e2b --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/CustomValidationException.java @@ -0,0 +1,16 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +public class CustomValidationException extends RuntimeException { + + private final Status status; + private static final long serialVersionUID = 1L; + + public Status getStatus() { + return status; + } + + public CustomValidationException(Status status, String message) { + super(message); + this.status = status; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ErrorConstants.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ErrorConstants.java new file mode 100644 index 00000000..d48defba --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ErrorConstants.java @@ -0,0 +1,28 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +import java.net.URI; + +public final class ErrorConstants { + + public static final String ERR_CONCURRENCY_FAILURE = "error.concurrencyFailure"; + public static final String ERR_VALIDATION = "error.validation"; + public static final String PROBLEM_BASE_URL = "https://www.jhipster.tech/problem"; + public static final URI DEFAULT_TYPE = URI.create(PROBLEM_BASE_URL + "/problem-with-message"); + public static final URI CONSTRAINT_VIOLATION_TYPE = URI.create(PROBLEM_BASE_URL + "/constraint-violation"); + public static final URI INVALID_PASSWORD_TYPE = URI.create(PROBLEM_BASE_URL + "/invalid-password"); + public static final URI EMAIL_ALREADY_USED_TYPE = URI.create(PROBLEM_BASE_URL + "/email-already-used"); + public static final URI LOGIN_ALREADY_USED_TYPE = URI.create(PROBLEM_BASE_URL + "/login-already-used"); + + public static final String BADREQUEST_ERROR_EXAMPLE="{\"data\": null," + +"\"status\": \"VALIDATION_ERROR\",\"message\": \"string\"" + + "}"; + public static final String NOTFOUND_ERROR_EXAMPLE="{\"data\": null," + +"\"status\": \"NOT_FOUND\",\"message\": \"string\"" + + "}"; + public static final String UNAUTHORIZED_ERROR_EXAMPLE="{\"data\": null," + +"\"status\": \"UNAUTHORIZED\",\"message\": \"string\"" + + "}"; + + private ErrorConstants() { + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ForbiddenAccessException.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ForbiddenAccessException.java new file mode 100644 index 00000000..9b448f6a --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ForbiddenAccessException.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(value = HttpStatus.FORBIDDEN) +public class ForbiddenAccessException extends RuntimeException { + + /** + * + */ + private static final long serialVersionUID = 1L; + private final Status status; + + public ForbiddenAccessException(Status status, String message) { + super(message); + this.status = status; + } + + public Status getStatus() { + return status; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/GlobalExceptionHandler.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/GlobalExceptionHandler.java new file mode 100644 index 00000000..1118da03 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/GlobalExceptionHandler.java @@ -0,0 +1,125 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.model.util.Response; + +import java.util.ArrayList; +import java.util.List; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.MethodArgumentNotValidException; +import org.springframework.web.bind.annotation.ControllerAdvice; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.ResponseBody; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.security.authentication.BadCredentialsException; +import org.springframework.security.authorization.AuthorizationDeniedException; +import org.springframework.security.core.AuthenticationException; +import org.springframework.validation.FieldError; +import org.springframework.validation.ObjectError; + +@ControllerAdvice +public class GlobalExceptionHandler { + + public final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class); + + @ResponseStatus(value = HttpStatus.BAD_REQUEST) + @ExceptionHandler(CustomValidationException.class) + @ResponseBody + public Response handleCustomValidationException(final CustomValidationException ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(null, ex.getStatus(), ex.getMessage()); + } + + @ResponseStatus(value = HttpStatus.BAD_REQUEST) + @ExceptionHandler(ValidationException.class) + @ResponseBody + public Response handleValidationException(final ValidationException ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(ex.getErrors(), ex.getStatus(), ex.getMessage()); + } + + @ExceptionHandler(ResourceNotFoundException.class) + public ResponseEntity> handleResourceNotFoundException(ResourceNotFoundException ex) { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response<>(null, ex.getStatus(), ex.getMessage())); + } + + @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR) + @ExceptionHandler(Exception.class) + @ResponseBody + public Response handleThrowable(final Throwable ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(null, Status.EXCEPTION_ERROR, Translator.toLocale("common_message")); + } + + @ResponseStatus(value = HttpStatus.UNAUTHORIZED) + @ExceptionHandler(AuthenticationException.class) + @ResponseBody + public Response handleInvalidTokenException(final Throwable ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(ex.getMessage(), Status.UNAUTHORIZED, Translator.toLocale("invalid_signature")); + } + + @ResponseStatus(value = HttpStatus.UNAUTHORIZED) + @ExceptionHandler({ UnauthorizedAccessException.class, AuthorizationDeniedException.class }) + @ResponseBody + public Response unauthorizedAccessException(final Throwable ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(null, Status.UNAUTHORIZED, ex.getMessage()); + } + + @ResponseStatus(value = HttpStatus.FORBIDDEN) + @ExceptionHandler(ForbiddenAccessException.class) + @ResponseBody + public Response forbiddenAccessException(final Throwable ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(null, Status.FORBIDDEN, ex.getMessage()); + } + + @ResponseStatus(value = HttpStatus.BAD_REQUEST) + @ExceptionHandler(MethodArgumentNotValidException.class) + @ResponseBody + public Response handleValiationException(final MethodArgumentNotValidException ex) { + + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + final List errors = new ArrayList(); + for (final FieldError error : ex.getBindingResult().getFieldErrors()) { + errors.add(error.getField() + ": " + error.getDefaultMessage()); + } + for (final ObjectError error : ex.getBindingResult().getGlobalErrors()) { + errors.add(error.getObjectName() + ": " + error.getDefaultMessage()); + } + return new Response<>(errors, Status.VALIDATION_ERROR, Translator.toLocale("req_validation_er")); + } + + @ResponseStatus(value = HttpStatus.UNAUTHORIZED) + @ExceptionHandler(BadCredentialsException.class) + @ResponseBody + public Response handleUnAuthorizedException(final Throwable ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(null, Status.VALIDATION_ERROR, Translator.toLocale("invalid_login")); + } + + @ResponseStatus(value = HttpStatus.BAD_REQUEST) + @ExceptionHandler(BadRequestAlertException.class) + @ResponseBody + public Response badRequestAlertException(final Throwable ex) { + log.error(ex.getMessage()); + log.error(ex.getLocalizedMessage(), ex); + return new Response<>(null, Status.EXCEPTION_ERROR, ex.getMessage()); + } + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ResourceNotFoundException.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ResourceNotFoundException.java new file mode 100644 index 00000000..bdc1bcc0 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ResourceNotFoundException.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(value = HttpStatus.NOT_FOUND) +public class ResourceNotFoundException extends RuntimeException { + + /** + * + */ + private static final long serialVersionUID = 1L; +private final Status status; + + public ResourceNotFoundException(Status status, String message) { + super(message); + this.status = status; + } + + public Status getStatus() { + return status; + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/Status.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/Status.java new file mode 100644 index 00000000..dc713f3e --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/Status.java @@ -0,0 +1,16 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +public enum Status { + SUCCESS("1"), VALIDATION_ERROR("2"), EXCEPTION_ERROR("3") , NOT_FOUND("4") , BAD_REQUEST("5") , UNAUTHORIZED("6") , + FORBIDDEN("7"), VALIDATION_COMPLETED("8"); + + private String action; + + public String getAction() { + return this.action; + } + + private Status(String action) { + this.action = action; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/UnauthorizedAccessException.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/UnauthorizedAccessException.java new file mode 100644 index 00000000..34f1b5ef --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/UnauthorizedAccessException.java @@ -0,0 +1,23 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(value = HttpStatus.UNAUTHORIZED) +public class UnauthorizedAccessException extends RuntimeException { + + /** + * + */ + private static final long serialVersionUID = 1L; + private final Status status; + + public UnauthorizedAccessException(Status status, String message) { + super(message); + this.status = status; + } + + public Status getStatus() { + return status; + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ValidationException.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ValidationException.java new file mode 100644 index 00000000..8af6f41a --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/errors/ValidationException.java @@ -0,0 +1,27 @@ +package net.gepafin.tendermanagement.web.rest.api.errors; + +import java.util.List; + +public class ValidationException extends CustomValidationException { + + private final Status status; + private static final long serialVersionUID = 1L; + private final List errors; + + public ValidationException(Status status, List errors, String message) { + super(status, message); + this.errors = errors; + this.status = status; + } + + + public List getErrors() { + return errors; + } + + public Status getStatus() { + return status; + } + + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/ApplicationApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/ApplicationApiController.java new file mode 100644 index 00000000..1d8b205b --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/ApplicationApiController.java @@ -0,0 +1,92 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.ApplicationRequest; +import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum; +import net.gepafin.tendermanagement.enums.FormActionEnum; +import net.gepafin.tendermanagement.model.request.ApplicationRequestBean; +import net.gepafin.tendermanagement.model.response.ApplicationGetResponseBean; +import net.gepafin.tendermanagement.model.response.ApplicationResponse; +import net.gepafin.tendermanagement.model.response.ApplicationResponseBean; +import net.gepafin.tendermanagement.model.response.NextOrPreviousFormResponse; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.ApplicationService; +import net.gepafin.tendermanagement.web.rest.api.ApplicationApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; +import org.slf4j.Logger; + +import java.util.List; + + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/application}") +public class ApplicationApiController implements ApplicationApi { + + private final Logger log = LoggerFactory.getLogger(ApplicationApiController.class); + + @Autowired + private ApplicationService applicationService; + + @Override + public ResponseEntity> createApplication(HttpServletRequest request, ApplicationRequestBean applicationRequestBean,Long applicationId, Long formId) { + ApplicationResponseBean applicationResponseBean= applicationService.createApplication(request,applicationRequestBean,applicationId,formId); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(applicationResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.APPLICATION_CREATED_SUCCESS_MSG))); } + + @Override + public ResponseEntity> getApplicationByFormId(HttpServletRequest request + , Long applicationId,Long formId) { + log.info("Get Application by ID - Application ID: {}", applicationId); + ApplicationGetResponseBean application = applicationService.getApplicationByFormId(request,applicationId,formId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(application, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_APPLICATION_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> deleteApplication(HttpServletRequest request, + Long applicationId) { + log.info("Delete Application - Application ID: {}", applicationId); + applicationService.deleteApplication(request,applicationId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.DELETE_APPLICATION_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> createApplicationByCallId(HttpServletRequest request, ApplicationRequest applicationRequest, Long callId) { + ApplicationResponse applicationResponseBean=applicationService.createApplication(request,applicationRequest,callId); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(applicationResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.APPLICATION_CREATED_SUCCESS_MSG))); + } + @Override + public ResponseEntity>> getAllApplications(HttpServletRequest request,Long callId) { + List applications = applicationService.getAllApplications(request,callId); + log.info("Get All Applications"); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(applications, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_APPLICATION_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> getNextOrPreviousForm(HttpServletRequest request,Long applicationId, + Long formId, FormActionEnum action) { + NextOrPreviousFormResponse data = applicationService.getNextOrPreviousForm(request, applicationId, formId, action); + log.info("Get Next Or Previous Form "); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(data, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_APPLICATION_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> updateApplicationStatus(HttpServletRequest request, Long applicationId, + ApplicationStatusTypeEnum status) { + applicationService.updateApplicationStatus(request, applicationId, status); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_APPLICATION_SUCCESS_MSG))); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/CallApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/CallApiController.java new file mode 100644 index 00000000..e4680428 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/CallApiController.java @@ -0,0 +1,87 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import java.util.List; + +import net.gepafin.tendermanagement.enums.CallStatusEnum; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep1; +import net.gepafin.tendermanagement.model.request.CreateCallRequestStep2; +import net.gepafin.tendermanagement.model.request.UpdateCallRequestStep1; +import net.gepafin.tendermanagement.model.response.CallDetailsResponseBean; +import net.gepafin.tendermanagement.model.response.CallResponse; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.CallService; +import net.gepafin.tendermanagement.web.rest.api.CallApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; + + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/call}") +public class CallApiController implements CallApi { + + @Autowired + private CallService callService; + + + @Override + @Transactional(rollbackFor=Exception.class) + public ResponseEntity> createCallStep1(HttpServletRequest request, CreateCallRequestStep1 createCallRequest) { + CallResponse createCallResponseBean = callService.createCallStep1(request, createCallRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(createCallResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.CALL_CREATED_SUCCESSFULLY_MSG))); + } + + @Override + @Transactional(rollbackFor=Exception.class) + public ResponseEntity> createCallStep2(HttpServletRequest request, Long callId, CreateCallRequestStep2 createCallRequest) { + CallResponse createCallResponseBean = callService.createCallStep2(request, callId, createCallRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(createCallResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.CALL_CREATED_SUCCESSFULLY_MSG))); + } + + @Override + @Transactional(rollbackFor=Exception.class) + public ResponseEntity> updateCallStep1(HttpServletRequest request, Long callId, UpdateCallRequestStep1 updateCallRequest) { + CallResponse createCallResponseBean = callService.updateCallStep1(request, callId, updateCallRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(createCallResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.CALL_UPDATE_SUCCESSFULLY_MSG))); + } + @Override + @Transactional(readOnly = true) + public ResponseEntity> getCallById(Long callId) { + CallResponse createCallResponseBean = callService.getCallById(callId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(createCallResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.CALL_FETCH_SUCCESS_MSG))); + } + + @Override + @Transactional(readOnly = true) + public ResponseEntity>> getAllCalls(HttpServletRequest request) { + List calls = callService.getAllCalls(request); + + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(calls, Status.SUCCESS, Translator.toLocale(GepafinConstant.CALL_FETCH_SUCCESS_MSG))); + + } + @Override + public ResponseEntity> validateCallData(HttpServletRequest request, Long callId) { + CallResponse call = callService.validateCallData(callId); + + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(call, Status.SUCCESS, Translator.toLocale(GepafinConstant.CALL_FETCH_SUCCESS_MSG))); + } + @Override + public ResponseEntity> updateCallStatus(HttpServletRequest request, Long callId, CallStatusEnum status) { + CallResponse updateCall = callService.updateCallStatus(request, callId, status); + return ResponseEntity.ok(new Response<>(updateCall, Status.SUCCESS, Translator.toLocale(GepafinConstant.UPDATE_CALL_STATUS_SUCCESS_MSG))); + } +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/CustomUserDetailsService.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/CustomUserDetailsService.java new file mode 100644 index 00000000..71f60387 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/CustomUserDetailsService.java @@ -0,0 +1,51 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import net.gepafin.tendermanagement.entities.RoleEntity; +import net.gepafin.tendermanagement.entities.UserEntity; +import net.gepafin.tendermanagement.repositories.UserRepository; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.security.core.GrantedAuthority; +import org.springframework.security.core.authority.SimpleGrantedAuthority; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.security.core.userdetails.UserDetailsService; +import org.springframework.security.core.userdetails.UsernameNotFoundException; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.Collections; + +@Service +public class CustomUserDetailsService implements UserDetailsService { + + private final Logger log = LoggerFactory.getLogger(CustomUserDetailsService.class); + + private final UserRepository userRepository; + + public CustomUserDetailsService(UserRepository userRepository) { + this.userRepository = userRepository; + } + + @Override + @Transactional + public UserDetails loadUserByUsername(final String email) throws UsernameNotFoundException { + log.debug("Authenticating {}", email); + + UserEntity user = userRepository.findByEmailIgnoreCase(email) + .orElseThrow( + () -> new UsernameNotFoundException("User " + email + " was not found in the database")); + return createSpringSecurityUser(user); + } + + private org.springframework.security.core.userdetails.User createSpringSecurityUser(UserEntity user) { + RoleEntity role = user.getRoleEntity(); + GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(role.getRoleType()); + + return new org.springframework.security.core.userdetails.User( + user.getEmail(), + user.getPassword(), + Collections.singletonList(grantedAuthority) + ); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/DocumentApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/DocumentApiController.java new file mode 100644 index 00000000..7141a256 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/DocumentApiController.java @@ -0,0 +1,61 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum; +import net.gepafin.tendermanagement.enums.DocumentTypeEnum; +import net.gepafin.tendermanagement.model.response.DocumentResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.DocumentService; +import net.gepafin.tendermanagement.web.rest.api.DocumentApi; +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.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; + +import java.util.List; + +@RestController +@RequestMapping("${openapi.swaggerBflowsMiddleware.base-path:/v1/document}") +public class +DocumentApiController implements DocumentApi { + + @Autowired + private DocumentService documentService; + + @Override + public ResponseEntity>> uploadFile(HttpServletRequest httpServletRequest, Long sourceId, DocumentSourceTypeEnum sourceType, + List files, DocumentTypeEnum fileType) { + try { + List responseBeans = documentService.uploadFile(files, sourceId,sourceType, fileType); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response>(responseBeans, Status.SUCCESS, Translator.toLocale(GepafinConstant.FILES_UPLOADED_MSG))); + } catch (CustomValidationException ex) { + throw ex; + } + } + @Override + public ResponseEntity> deleteFile(HttpServletRequest httpServletRequest, Long documentId) { + documentService.deleteFile(documentId); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.FILE_DELETED_SUCCESSFULLY_MSG))); + } + + @Override + public ResponseEntity> updateDocument(HttpServletRequest httpServletRequest, Long documentId, MultipartFile file, DocumentTypeEnum documentTypeEnum) { + DocumentResponseBean responseBeans = documentService.updateDocument(httpServletRequest, documentId, file, documentTypeEnum); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response(responseBeans, Status.SUCCESS, Translator.toLocale(GepafinConstant.DOCUMENT_UPDATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getDocumentById(HttpServletRequest request, Long id) { + DocumentResponseBean documentResponseBean= documentService.getDocument(request,id); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response(documentResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.DOCUMENT_FETCHED_SUCCESSFULLY))); +} +} \ No newline at end of file diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/EvaluationCriteriaApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/EvaluationCriteriaApiController.java new file mode 100644 index 00000000..6c6286ae --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/EvaluationCriteriaApiController.java @@ -0,0 +1,66 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.EvaluationCriteriaRequest; +import net.gepafin.tendermanagement.model.response.EvaluationCriteriaResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.EvaluationCriteriaService; +import net.gepafin.tendermanagement.web.rest.api.EvaluationCriteriaApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; + +import jakarta.servlet.http.HttpServletRequest; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/evaluationCriteria}") +public class EvaluationCriteriaApiController implements EvaluationCriteriaApi { + + @Autowired + private EvaluationCriteriaService service; + + @Override + public ResponseEntity> createEvaluationCriteria(HttpServletRequest request, EvaluationCriteriaRequest evaluationCriteriaRequest) { + EvaluationCriteriaResponseBean responseBean = service.createEvaluationCriteria(request,evaluationCriteriaRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(responseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_CREATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getEvaluationCriteriaById(HttpServletRequest request, Long id) { + EvaluationCriteriaResponseBean responseBean = service.getEvaluationCriteria(request,id); + if (responseBean != null) { + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(responseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_FETCH_SUCCESSFULLY))); + } else { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response<>(null, Status.NOT_FOUND, Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_NOT_FOUND))); + } + } + + @Override + @Transactional(rollbackFor=Exception.class) + public ResponseEntity> updateEvaluationCriteria(HttpServletRequest request, Long id, EvaluationCriteriaRequest evaluationCriteriaRequest) { + EvaluationCriteriaResponseBean responseBean = service.updateEvaluationCriteria(request,id, evaluationCriteriaRequest); + if (responseBean != null) { + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(responseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_UPDATED_SUCCESSFULLY))); + } else { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response<>(null, Status.NOT_FOUND, Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_NOT_FOUND))); + } + } + + @Override + public ResponseEntity deleteEvaluationCriteria(HttpServletRequest request, Long id) { + service.deleteEvaluationCriteria(request,id); + return ResponseEntity.status(HttpStatus.OK) + .header("Message", Translator.toLocale(GepafinConstant.EVALUATION_CRITERIA_DELETED_SUCCESSFULLY)) + .build(); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FaqApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FaqApiController.java new file mode 100644 index 00000000..142e5614 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FaqApiController.java @@ -0,0 +1,61 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.FaqReq; +import net.gepafin.tendermanagement.model.response.FaqResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.FaqService; +import net.gepafin.tendermanagement.web.rest.api.FaqApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/faq}") +public class FaqApiController implements FaqApi { + + @Autowired + private FaqService faqService; + + @Override + public ResponseEntity> createFaq(HttpServletRequest request, Long callId,FaqReq faqRequest) { + FaqResponseBean response = faqService.createFaq(request,callId, faqRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(response, Status.SUCCESS, Translator.toLocale(GepafinConstant.FAQ_CREATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getFaqById(HttpServletRequest request, Long id) { + FaqResponseBean response = faqService.getFaqById(request, id); + if (response != null) { + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(response, Status.SUCCESS, Translator.toLocale(GepafinConstant.FAQ_FETCHED_SUCCESSFULLY))); + } else { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response<>(null, Status.NOT_FOUND, Translator.toLocale(GepafinConstant.FAQ_NOT_FOUND))); + } + } + + @Override + public ResponseEntity> updateFaq(HttpServletRequest request, Long id, FaqReq faqRequest) { + FaqResponseBean response = faqService.updateFaq(request, id, faqRequest); + if (response != null) { + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(response, Status.SUCCESS, Translator.toLocale(GepafinConstant.FAQ_UPDATED_SUCCESSFULLY))); + } else { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response<>(null, Status.NOT_FOUND, Translator.toLocale(GepafinConstant.FAQ_NOT_FOUND))); + } + } + + @Override + public ResponseEntity> deleteFaq(HttpServletRequest request, Long id) { + faqService.deleteFaq(request, id); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.FAQ_DELETED_SUCCESSFULLY))); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FlowApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FlowApiController.java new file mode 100644 index 00000000..68cb183b --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FlowApiController.java @@ -0,0 +1,39 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.FlowRequestBean; +import net.gepafin.tendermanagement.model.response.FlowResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.FlowService; +import net.gepafin.tendermanagement.web.rest.api.FlowApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/flow}") +public class FlowApiController implements FlowApi { + + @Autowired + private FlowService flowService; + + @Override + public ResponseEntity> createOrUpdateFlow(HttpServletRequest httpServletRequest, FlowRequestBean flowRequestBean, Long callId) { + FlowResponseBean flowResponseBean=flowService.createOrUpdateFlow(httpServletRequest,flowRequestBean,callId); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(flowResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FLOW_CREATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getFlowByCallId(HttpServletRequest request, Long callId) { + FlowResponseBean flowResponseBean=flowService.getFlowByCallId(request,callId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(flowResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FLOW_FETCHED_SUCCESSFULLY))); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormApiController.java new file mode 100644 index 00000000..5b8b54a5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormApiController.java @@ -0,0 +1,62 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.FormRequest; +import net.gepafin.tendermanagement.model.response.FormResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.FormService; +import net.gepafin.tendermanagement.web.rest.api.FormApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/form}") +public class FormApiController implements FormApi { + + @Autowired + private FormService formService; + + @Override + public ResponseEntity> createForm(HttpServletRequest request,Long callId, FormRequest formRequest) { + FormResponseBean formResponseBean = formService.createForm(request,callId, formRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(formResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_CREATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> updateForm(HttpServletRequest request, Long formId, FormRequest formRequest,Boolean forceDeleteFlow) { + FormResponseBean formResponseBean = formService.updateForm(request, formId, formRequest,forceDeleteFlow); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(formResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_UPDATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getFormById(HttpServletRequest request, Long formId) { + FormResponseBean formResponseBean=formService.getFormById(request,formId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(formResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FETCHED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> deleteForm(HttpServletRequest request, Long formId) { + formService.deleteForm(request,formId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_DELETED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity>> getFormsByCallId(HttpServletRequest request, Long callId) { + List formResponseBean=formService.getFormsByCallId(request,callId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(formResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FETCHED_SUCCESSFULLY))); + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormFieldApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormFieldApiController.java new file mode 100644 index 00000000..e491d498 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormFieldApiController.java @@ -0,0 +1,61 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.FormFieldRequest; +import net.gepafin.tendermanagement.model.response.FormFieldResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.FormFieldService; +import net.gepafin.tendermanagement.web.rest.api.FormFieldApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/formField}") +public class FormFieldApiController implements FormFieldApi { + + @Autowired + private FormFieldService formFieldService; + + @Override + public ResponseEntity> createFormField(HttpServletRequest request, FormFieldRequest formFieldRequest) { + FormFieldResponseBean formFieldResponseBean=formFieldService.createFormField(request,formFieldRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(formFieldResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FIELD_CREATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> updateFormField(HttpServletRequest request, Long formFieldId, FormFieldRequest formFieldRequest) { + FormFieldResponseBean formFieldResponseBean=formFieldService.updateFormField(request,formFieldId,formFieldRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(formFieldResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FIELD_UPDATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getFormFieldById(HttpServletRequest request, Long formFieldId) { + FormFieldResponseBean formFieldResponseBean=formFieldService.getFormFieldById(request,formFieldId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(formFieldResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FIELD_FETCHED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> deleteForm(HttpServletRequest request, Long formFieldId) { + formFieldService.deleteFormField(request,formFieldId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FIELD_DELETED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity>> getAllFormField(HttpServletRequest request) { + List formFieldResponseBeans=formFieldService.getAllFormField(request); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(formFieldResponseBeans, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FIELD_FETCHED_SUCCESSFULLY))); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormTemplateApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormTemplateApiController.java new file mode 100644 index 00000000..058e1655 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/FormTemplateApiController.java @@ -0,0 +1,61 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.FormTemplateRequest; +import net.gepafin.tendermanagement.model.response.FormTemplateResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.FormTemplateService; +import net.gepafin.tendermanagement.web.rest.api.FormTemplateApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/formTemplate}") +public class FormTemplateApiController implements FormTemplateApi { + + @Autowired + private FormTemplateService formTemplateService; + + @Override + public ResponseEntity> createFormTemplate(HttpServletRequest request, FormTemplateRequest formTemplateRequest) { + FormTemplateResponseBean formTemplateResponseBean=formTemplateService.createTemplateForm(request,formTemplateRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(formTemplateResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_TEMPLATE_CREATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> updateFormTemplate(HttpServletRequest request, Long formTemplateId, FormTemplateRequest formTemplateRequest) { + FormTemplateResponseBean formTemplateResponseBean=formTemplateService.updateTemplateForm(request,formTemplateId,formTemplateRequest); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(formTemplateResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_TEMPLATE_UPDATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getFormTemplateById(HttpServletRequest request, Long formTemplateId) { + FormTemplateResponseBean formTemplateResponseBean=formTemplateService.getFormTemplateById(request, formTemplateId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(formTemplateResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_TEMPLATE_FETCHED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> deleteFormTemplate(HttpServletRequest request, Long formTemplateId) { + formTemplateService.deleteFormTemplate(request,formTemplateId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_TEMPLATE_DELETED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity>> getAllFormTemplate(HttpServletRequest request) { + List formTemplateResponseBeans=formTemplateService.getAllFormTemplate(request); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(formTemplateResponseBeans, Status.SUCCESS, Translator.toLocale(GepafinConstant.FORM_FIELD_FETCHED_SUCCESSFULLY))); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/LookUpDataApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/LookUpDataApiController.java new file mode 100644 index 00000000..3f79198c --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/LookUpDataApiController.java @@ -0,0 +1,76 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum; +import net.gepafin.tendermanagement.model.request.LookUpDataRequest; +import net.gepafin.tendermanagement.model.response.LookUpDataResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.LookUpDataService; +import net.gepafin.tendermanagement.web.rest.api.LookUpDataApi; +import net.gepafin.tendermanagement.web.rest.api.errors.Status; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/lookUpData}") +public class LookUpDataApiController implements LookUpDataApi { + + @Autowired + private LookUpDataService lookUpDataService; + + @Override + public ResponseEntity> createLookUpData(HttpServletRequest request, LookUpDataRequest lookUpDataReq) { + LookUpDataResponseBean responseBean = lookUpDataService.createLookUpData(lookUpDataReq); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response(responseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.LOOKUP_DATA_CREATED_SUCCESSFULLY))); + } + + @Override + public ResponseEntity> getLookUpDataById(HttpServletRequest request, Long id) { + LookUpDataResponseBean responseBean = lookUpDataService.getLookUpDataById(id); + if (responseBean != null) { + return ResponseEntity.status(HttpStatus.OK) + .body(new Response(responseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.LOOKUP_DATA_FETCHED_SUCCESSFULLY))); + } else { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response(responseBean, Status.NOT_FOUND, Translator.toLocale(GepafinConstant.LOOKUP_DATA_NOT_FOUND))); + } + } + + @Override + public ResponseEntity> updateLookUpData(HttpServletRequest request, Long id, LookUpDataRequest lookUpDataReq) { + LookUpDataResponseBean responseBean = lookUpDataService.updateLookUpData(id, lookUpDataReq); + if (responseBean != null) { + return ResponseEntity.status(HttpStatus.OK) + .body(new Response(responseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.LOOKUP_DATA_UPDATED_SUCCESSFULLY))); + } else { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response(responseBean, Status.NOT_FOUND, Translator.toLocale(GepafinConstant.LOOKUP_DATA_NOT_FOUND))); + } + } + + @Override + public ResponseEntity> deleteLookUpData(HttpServletRequest request, Long id) { + lookUpDataService.deleteLookUpData(id); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.LOOKUP_DATA_DELETED_SUCCESSFULLY))); + } + @Override + public ResponseEntity>> getLookUpDataByType(HttpServletRequest request, List type) { + List responseBean = lookUpDataService.getLookUpDataByType(type); + if (responseBean != null) { + return ResponseEntity.status(HttpStatus.OK) + .body(new Response>(responseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.LOOKUP_DATA_FETCHED_SUCCESSFULLY))); + } else { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(new Response>(responseBean, Status.NOT_FOUND, Translator.toLocale(GepafinConstant.LOOKUP_DATA_NOT_FOUND))); + } + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/RegionApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/RegionApiController.java new file mode 100644 index 00000000..b3f3a4bf --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/RegionApiController.java @@ -0,0 +1,77 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.RegionReq; +import net.gepafin.tendermanagement.model.response.RegionResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.RegionService; +import net.gepafin.tendermanagement.web.rest.api.RegionApi; +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.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/region}") +public class RegionApiController implements RegionApi { + + private final Logger log = LoggerFactory.getLogger(RegionApiController.class); + + @Autowired + private RegionService regionService; + + @Override + public ResponseEntity> createRegion( + @Valid @RequestBody RegionReq regionReq) { + log.info("Create Region - Request Body: {}", regionReq); + RegionResponseBean createdRegion = regionService.createRegion(regionReq); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(createdRegion, Status.SUCCESS, Translator.toLocale(GepafinConstant.REGION_CREATED_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> updateRegion( + @PathVariable("regionId") Long regionId, + @Valid @RequestBody RegionReq regionReq) { + log.info("Update Region - Region ID: {}, Request Body: {}", regionId, regionReq); + RegionResponseBean updatedRegion = regionService.updateRegion(regionId, regionReq); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(updatedRegion, Status.SUCCESS, Translator.toLocale(GepafinConstant.REGION_UPDATED_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> getRegionById( + @PathVariable("regionId") Long regionId) { + log.info("Get Region by ID - Region ID: {}", regionId); + RegionResponseBean region = regionService.getRegionById(regionId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(region, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_REGION_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> deleteRegion( + @PathVariable("regionId") Long regionId) { + log.info("Delete Region - Region ID: {}", regionId); + regionService.deleteRegion(regionId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.DELETE_REGION_SUCCESS_MSG))); + } + @Override + public ResponseEntity>> getAllRegions() { + List regions = regionService.getAllRegions(); + log.info("Get All Region"); + regionService.getAllRegions(); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(regions, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_REGION_SUCCESS_MSG))); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/RoleApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/RoleApiController.java new file mode 100644 index 00000000..284552ba --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/RoleApiController.java @@ -0,0 +1,74 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import java.util.List; + +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.model.request.RoleReq; +import net.gepafin.tendermanagement.model.response.RoleResponseBean; +import net.gepafin.tendermanagement.model.util.Response; +import net.gepafin.tendermanagement.service.RoleService; +import net.gepafin.tendermanagement.web.rest.api.RoleApi; +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.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/role}") +public class RoleApiController implements RoleApi { + + private static final Logger log = LoggerFactory.getLogger(RoleApiController.class); + + @Autowired + private RoleService roleService; + @Override + public ResponseEntity> createRole(RoleReq body) { + log.info("Create Role - Request Body: {}", body); + RoleResponseBean roleReq = roleService.createRole(body); + + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(roleReq, Status.SUCCESS, Translator.toLocale(GepafinConstant.ROLE_CREATED_SUCCESS_MSG))); + + } + + @Override + public ResponseEntity> updateRole(Long roleId, RoleReq body) { + log.info("Update Role - Role ID: {}, Request Body: {}", roleId, body); + RoleResponseBean updatedUserRole = roleService.updateRole(roleId, body); + + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(updatedUserRole, Status.SUCCESS, Translator.toLocale(GepafinConstant.ROLE_UPDATED_SUCCESS_MSG))); + } + + @Override + public ResponseEntity>> getAllRoles() { + log.info("Get All Roles"); + List roles = roleService.getAllRoles(); + + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(roles, Status.SUCCESS, Translator.toLocale(GepafinConstant.ROLE_FETCH_SUCCESS_MSG))); + + } + + @Override + public ResponseEntity> getRoleById(Long roleId) { + log.info("Get Role by ID - Role ID: {}", roleId); + RoleResponseBean roleResponseBean = roleService.getRoleById(roleId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(roleResponseBean, Status.SUCCESS, Translator.toLocale(GepafinConstant.ROLE_FETCH_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> deleteRole(Long roleId) { + log.info("Delete Role - Role ID: {}", roleId); + roleService.deleteRole(roleId); + + return ResponseEntity.status(HttpStatus.NO_CONTENT) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.ROLE_DELETED_SUCCESS_MSG))); + } +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/SamlApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/SamlApiController.java new file mode 100644 index 00000000..f49b9fa5 --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/SamlApiController.java @@ -0,0 +1,39 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.saml2.provider.service.metadata.OpenSamlMetadataResolver; +import org.springframework.security.saml2.provider.service.metadata.Saml2MetadataResolver; +import org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistration; +import org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistrationRepository; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import jakarta.servlet.http.HttpServletRequest; +import net.gepafin.tendermanagement.config.SecurityConfig; +import net.gepafin.tendermanagement.web.rest.api.SamlApi; + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/saml}") +public class SamlApiController implements SamlApi{ + + private final Logger logger = LoggerFactory.getLogger(SecurityConfig.class); + + @Autowired + private RelyingPartyRegistrationRepository relyingPartyRegistrationRepository; + + @Override + public ResponseEntity getMetadata(HttpServletRequest request) { + logger.info("get SP metadata"); + Saml2MetadataResolver metadataResolver = new OpenSamlMetadataResolver(); + RelyingPartyRegistration registration = relyingPartyRegistrationRepository.findByRegistrationId("loginumbria"); + return ResponseEntity.status(HttpStatus.OK).header("Content-Type", MediaType.APPLICATION_XML_VALUE) + .body(metadataResolver.resolve(registration)); + + } + +} diff --git a/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/UserApiController.java b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/UserApiController.java new file mode 100644 index 00000000..ca13268a --- /dev/null +++ b/src/main/java/net/gepafin/tendermanagement/web/rest/api/impl/UserApiController.java @@ -0,0 +1,143 @@ +package net.gepafin.tendermanagement.web.rest.api.impl; + +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import jakarta.validation.Valid; +import net.gepafin.tendermanagement.config.Translator; +import net.gepafin.tendermanagement.constants.GepafinConstant; +import net.gepafin.tendermanagement.enums.UserStatusEnum; +import net.gepafin.tendermanagement.model.request.*; +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.model.util.Response; +import net.gepafin.tendermanagement.service.UserService; +import net.gepafin.tendermanagement.web.rest.api.UserApi; +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.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + + +@RestController +@RequestMapping("${openapi.gepafin.base-path:/v1/user}") +@Validated +public class UserApiController implements UserApi { + + private final Logger log = LoggerFactory.getLogger(UserApiController.class); + + @Autowired + private UserService userService; + + @Override + public ResponseEntity> createUser(HttpServletRequest request, String tempToken, @RequestBody UserReq userReq) { + log.info("Create User with - Request Body: {}", userReq); + JWTToken createdUser = userService.createUser(request, tempToken, userReq); + return ResponseEntity.status(HttpStatus.CREATED) + .body(new Response<>(createdUser, Status.SUCCESS, Translator.toLocale(GepafinConstant.USER_CREATED_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> updateUser( + @PathVariable("userId") Long userId, + @Valid @RequestBody UpdateUserReq userReq) { + log.info("Update User - User ID: {}, Request Body: {}", userId, userReq); + UserResponseBean updatedUser = userService.updateUser(userId, userReq); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(updatedUser, Status.SUCCESS, Translator.toLocale(GepafinConstant.USER_UPDATED_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> getUserById( + @PathVariable("userId") Long userId) { + log.info("Get User by ID - User ID: {}", userId); + UserResponseBean user = userService.getUserById(userId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(user, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_USER_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> deleteUser( + @PathVariable("userId") Long userId) { + log.info("Delete User - User ID: {}", userId); + userService.deleteUser(userId); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.USER_DELETED_SUCCESS_MSG))); + } + + @Override + public ResponseEntity> login( + @Valid @RequestBody LoginReq loginReq) { + log.info("User login attempt "); + JWTToken jwtToken = userService.login(loginReq); + return ResponseEntity.ok(new Response<>(jwtToken, Status.SUCCESS, Translator.toLocale(GepafinConstant.LOGIN_SUCCESS_MSG))); + } + @Override + public ResponseEntity> changePassword(@Valid @RequestBody ChangePasswordRequest request) { + log.info("Change Password attempt for email: {}", request.getEmail()); + userService.changePassword(request); + return ResponseEntity.ok(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.SUCCESS_PASSWORD_CHANGED))); + } + @Override + public ResponseEntity> initiatePasswordReset(InitiatePasswordResetReq request) { + log.info("Initiating password reset for email: {}", request.getEmail()); + String resetToken = userService.initiatePasswordReset(request); + log.info("Password reset token generated for email: {}", request.getEmail()); + return ResponseEntity.ok(new Response<>(resetToken, Status.SUCCESS, Translator.toLocale(GepafinConstant.RESET_PASSWORD_INITIATED))); + } + + @Override + public ResponseEntity> resetPassword(ResetPasswordReq request) { + log.info("Resetting password for username: {}", request.getEmail()); + Boolean success = userService.resetPassword(request); + if (success) { + log.info("Password reset successfully for username: {}", request.getEmail()); + } else { + log.error("Password reset failed for username: {}", request.getEmail()); + } + return ResponseEntity.ok(new Response<>(success, Status.SUCCESS, Translator.toLocale(GepafinConstant.PASSWORD_RESET_SUCCESS))); + } + + @Override + public ResponseEntity> logoutUser(HttpServletRequest request, HttpServletResponse response) { + userService.logoutUser(request, response); + + log.info("User has successfully logged"); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(null, Status.SUCCESS, Translator.toLocale(GepafinConstant.LOGOUT_SUCCESSFUL_MSG))); + } + + @Override + public ResponseEntity> updateUserStatus(@PathVariable Long userId, @RequestParam UserStatusEnum status) { + log.info("Update User Status for- User ID: {}, Request Body: {}", userId, status); + UserResponseBean updatedUser = userService.updateUserStatus(userId, status); + return ResponseEntity.ok(new Response<>(updatedUser, Status.SUCCESS, Translator.toLocale(GepafinConstant.UPDATE_USER_STATUS_SUCCESS_MSG))); + } + @Override + public ResponseEntity> getValidUser(HttpServletRequest request) { + log.info("Get Valid User Detail"); + UserResponseBean user = userService.getValidUser(request); + return ResponseEntity.status(HttpStatus.OK) + .body(new Response<>(user, Status.SUCCESS, Translator.toLocale(GepafinConstant.GET_USER_SUCCESS_MSG))); + + } + + @Override + public ResponseEntity> validateExistingUserToken(HttpServletRequest request, String token) { + log.info("User login attempt via spid token"); + JWTToken data = userService.validateExistingUserToken(request, token); + return ResponseEntity.ok(new Response<>(data, Status.SUCCESS, Translator.toLocale(GepafinConstant.TOKEN_VALIDATE_SUCCESS_MSE))); + } + + @Override + public ResponseEntity> validateNewUserToken(HttpServletRequest request, String token) { + log.info("User validating spid token"); + UserSamlResponse data = userService.validateNewUserToken(request,token); + return ResponseEntity.ok(new Response<>(data, Status.SUCCESS, Translator.toLocale(GepafinConstant.TOKEN_VALIDATE_SUCCESS_MSE))); + } + +} \ No newline at end of file diff --git a/src/main/resources/application-dev.properties b/src/main/resources/application-dev.properties new file mode 100644 index 00000000..930cbd9f --- /dev/null +++ b/src/main/resources/application-dev.properties @@ -0,0 +1,11 @@ +# DataSource Configuration +spring.datasource.url=jdbc:postgresql://dbstaging.memento.credit:20184/gepaDb +spring.datasource.username=usergepa +spring.datasource.password=vs1pAc9vu07mMcdx93j6WiBS +spring.datasource.driver-class-name=org.postgresql.Driver + +# JPA Configuration +spring.h2.console.enabled=true +base-url=https://api-dev-gepafin.memento.credit + +isVatCheckGloballyDisabled = false diff --git a/src/main/resources/application-local.properties b/src/main/resources/application-local.properties new file mode 100644 index 00000000..6b925e03 --- /dev/null +++ b/src/main/resources/application-local.properties @@ -0,0 +1,9 @@ +# DataSource Configuration +spring.datasource.url=jdbc:postgresql://localhost:5432/gepafin_local +spring.datasource.username=postgres +spring.datasource.password=root +spring.datasource.driver-class-name=org.postgresql.Driver + +# JPA Configuration +spring.jpa.show-sql=true +base-url=http://localhost:8080 \ No newline at end of file diff --git a/src/main/resources/application-production.properties b/src/main/resources/application-production.properties new file mode 100644 index 00000000..be371126 --- /dev/null +++ b/src/main/resources/application-production.properties @@ -0,0 +1,11 @@ +# DataSource Configuration +spring.datasource.url=jdbc:postgresql://bandidb.gepafin.it:21543/gepaDb +spring.datasource.username=usergepa +spring.datasource.password=nRHMi7esdgHJiIm3L5ctrSJ0 +spring.datasource.driver-class-name=org.postgresql.Driver + +# JPA Configuration +spring.h2.console.enabled=true +base-url=http://bandi-api.gepafin.it + +isVatCheckGloballyDisabled = false diff --git a/src/main/resources/application-testing.properties b/src/main/resources/application-testing.properties new file mode 100644 index 00000000..12b95acb --- /dev/null +++ b/src/main/resources/application-testing.properties @@ -0,0 +1,8 @@ +# DataSource Configuration +spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1 +spring.datasource.username=sa +spring.datasource.password=sa + +# JPA Configuration +spring.h2.console.enabled=true +base-url=http://localhost:8080 \ No newline at end of file diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties new file mode 100644 index 00000000..1c16a251 --- /dev/null +++ b/src/main/resources/application.properties @@ -0,0 +1,46 @@ +spring.application.name=tendermanagement + +# Multipart Configuration +spring.servlet.multipart.max-file-size=50MB +spring.servlet.multipart.max-request-size=50MB + +spring.profiles.active=testing + + +# JPA Configuration +spring.jpa.properties.hibernate.default_schema=gepafin_schema +spring.jpa.hibernate.ddl-auto=none +spring.jpa.show-sql=false + + +# Liquibase Configuration +spring.liquibase.change-log=classpath:db/changelog/db.changelog-master.xml +spring.liquibase.default-schema=gepafin_schema +spring.liquibase.enabled=true + + +# Swagger Configuration +springdoc.api-docs.path=/v1/api-docs +springdoc.swagger-ui.tagsSorter=alpha + + +#aws configuration +aws.access.key.id=AKIAVWDQWCUEOSUN4LUW +aws.secret.access.key=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 +aws.s3.region=eu-west-1 +aws.s3.bucket.name=mementoresources +aws.s3.url = https://mementoresources.s3.eu-west-1.amazonaws.com/ +aws.s3.url.folder=gepafin +# JWT configuration +# Ensure these values match your expectations +security.authentication.jwt.secret=my-secret-token-to-change-in-prod-environment-your-super-secure-randomly-generated-key +security.authentication.jwt.token-validity-in-seconds=86400 +base-url=https://api-dev-gepafin.memento.credit + + +spring.main.allow-circular-references=true + +isVatCheckGloballyDisabled = true +vatCheckNewToken: 66026bd891a51044e90e08c4 +fe.base.url=http://gepafin-staging-fe.s3-website.eu-central-1.amazonaws.com + diff --git a/src/main/resources/db/changelog/db.changelog-1.0.0.xml b/src/main/resources/db/changelog/db.changelog-1.0.0.xml new file mode 100644 index 00000000..e8d546cd --- /dev/null +++ b/src/main/resources/db/changelog/db.changelog-1.0.0.xml @@ -0,0 +1,741 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + select + setval('gepafin_schema.form_field_id_seq', (select + max(id)+1 + from gepafin_schema.form_field), false) + + + + + + + + + + + + + + + + + + + + + + + + + + + + TRUNCATE TABLE FORM_FIELD RESTART IDENTITY; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TRUNCATE TABLE FORM_FIELD RESTART IDENTITY; + + + + + + + + + + + + + TRUNCATE TABLE FORM_FIELD RESTART IDENTITY; + + + + + + + + + + + + + + + + + + + id = 13 + + + + + + + + + + + + + + diff --git a/src/main/resources/db/changelog/db.changelog-master.xml b/src/main/resources/db/changelog/db.changelog-master.xml new file mode 100644 index 00000000..f44695c7 --- /dev/null +++ b/src/main/resources/db/changelog/db.changelog-master.xml @@ -0,0 +1,8 @@ + + + + + diff --git a/src/main/resources/db/dump/inserted_form_field_data_13_09_2024.sql b/src/main/resources/db/dump/inserted_form_field_data_13_09_2024.sql new file mode 100644 index 00000000..510b4e19 --- /dev/null +++ b/src/main/resources/db/dump/inserted_form_field_data_13_09_2024.sql @@ -0,0 +1,51 @@ +INSERT INTO FORM_FIELD ( SORT_ORDER, NAME, LABEL, DESCRIPTION, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) +VALUES +( 1, 'textinput', 'Testo Breve', 'Per risposte concise (nomi, titoli, brevi descrizioni)', + '{"label": "Testo Breve", "placeholder": ""}', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 2, 'textarea', 'Testo Lungo', 'Campo di testo esteso per paragrafi, descrizioni, proposte', + '{"label": "Testo Lungo", "placeholder": ""}', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 3, 'wysiwyg', 'Campo di Testo Formattato', 'Editor avanzato per testo con formattazione', + '{"label": "Testo Formattato", "placeholder": ""}', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 4, 'numberinput', 'Campo Numerico', 'Per l''inserimento di valori numerici (quantità, importi, percentuali)', + '{"label": "Numero", "placeholder": "0", "step": "0"}', + '{"isRequired": false, "min": null, "max": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(5, 'radio', 'Scelta Singola', 'Gruppo di opzioni per selezione singola', + '{"label": "Scelta Singola", "options": []}', + '{"isRequired": false, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 6, 'select', 'Menu a Tendina', 'Selezione da opzioni predefinite', + '{"label": "Menu a Tendina", "options": []}', + '{"isRequired": false, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 7, 'checkboxes', 'Scelta Multipla', 'Gruppo di opzioni per selezione singola o multipla', + '{"label": "Scelta Multipla", "options": []}', + '{"isRequired": false, "min": null, "max": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 8, 'switch', 'Casella di Spunta', 'Per selezioni binarie, accettazioni, conferme', + '{"label": "Casella di Spunta"}', + '{"isRequired": false}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 9, 'datepicker', 'Data', 'Selezione di data', + '{"label": "Data"}', + '{"isRequired": false, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +( 10, 'fileupload', 'Caricamento File', 'Per l''upload di documenti o immagini', + '{"label": "Caricamento File", "mime": []}', + '{"isRequired": false, "maxSize": 100000, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP); diff --git a/src/main/resources/db/dump/inserted_form_field_data_30_08_2024.sql b/src/main/resources/db/dump/inserted_form_field_data_30_08_2024.sql new file mode 100644 index 00000000..06e02a9f --- /dev/null +++ b/src/main/resources/db/dump/inserted_form_field_data_30_08_2024.sql @@ -0,0 +1,128 @@ +INSERT INTO FORM_FIELD (NAME, LABEL, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) +VALUES ( + 'textinput', + 'Text Input', + '[ + { + "name": "label", + "value": "Text input" + }, + { + "name": "placeholder", + "value": "Placeholder text" + } + ]', + '{ + "isRequired": false, + "minLength": null, + "maxLength": null, + "pattern": null, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +); +INSERT INTO FORM_FIELD (NAME, LABEL, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) +VALUES +( 'textarea', + 'Text Area', + '[ + { + "name": "label", + "value": "Text area" + }, + { + "name": "placeholder", + "value": "Placeholder text" + } + ]', + '{ + "isRequired": false, + "minLength": null, + "maxLength": null, + "pattern": null, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +); + +INSERT INTO FORM_FIELD ( NAME, LABEL, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) +VALUES +( 'textinput', + 'Number Input', + '[ + { + "name": "label", + "value": "Number" + }, + { + "name": "placeholder", + "value": "" + } + ]', + '{ + "isRequired": false, + "min": null, + "max": null, + "pattern": null, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +); + +INSERT INTO FORM_FIELD (NAME, LABEL, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) +VALUES +( 'textinput', + 'P.IVA', + '[ + { + "name": "label", + "value": "P.IVA" + }, + { + "name": "placeholder", + "value": "Insert p.iva number" + } + ]', + '{ + "isRequired": true, + "minLength": null, + "maxLength": null, + "pattern": null, + "custom": "isValidVAT" + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +); + +INSERT INTO FORM_FIELD (NAME, LABEL, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) +VALUES +( 'radio', + 'Radio Input', + '[ + { + "name": "label", + "value": "Radio input" + }, + { + "name": "options", + "value": [ + { + "name": "opt1", + "label": "Opt1" + } + ] + } + ]', + '{ + "isRequired": false, + "min": null, + "max": null, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +); + diff --git a/src/main/resources/db/dump/update_form_field_data_04_09_2024.sql b/src/main/resources/db/dump/update_form_field_data_04_09_2024.sql new file mode 100644 index 00000000..fbf9b951 --- /dev/null +++ b/src/main/resources/db/dump/update_form_field_data_04_09_2024.sql @@ -0,0 +1,110 @@ +INSERT INTO FORM_FIELD (NAME, LABEL, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) VALUES +( + 'textinput', + 'Text Input', + '[ + {"name": "label", "value": "Text input"}, + {"name": "placeholder", "value": "Placeholder text"} + ]', + '{ + "isRequired": false, + "minLength": null, + "maxLength": null, + "pattern": null, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +), +( + 'textarea', + 'Text Area', + '[ + {"name": "label", "value": "Text area"}, + {"name": "placeholder", "value": "Placeholder text"} + ]', + '{ + "isRequired": false, + "minLength": null, + "maxLength": null, + "pattern": null, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +), +( + 'numberinput', + 'Number Input', + '[ + {"name": "label", "value": "Number"}, + {"name": "placeholder", "value": 0} + ]', + '{ + "isRequired": false, + "min": null, + "max": null, + "pattern": null, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +), +( + 'textinput', + 'P.IVA', + '[ + {"name": "label", "value": "P.IVA"}, + {"name": "placeholder", "value": "Insert p.iva number"} + ]', + '{ + "isRequired": true, + "minLength": null, + "maxLength": null, + "pattern": null, + "custom": "isValidVAT" + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +), +( + 'radio', + 'Radio Input', + '[ + {"name": "label", "value": "Radio input"}, + {"name": "options", "value": []} + ]', + '{ + "isRequired": false, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +), +( + 'select', + 'Select', + '[ + {"name": "label", "value": "Select"}, + {"name": "options", "value": []} + ]', + '{ + "isRequired": false, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +), +( + 'datepicker', + 'Datepicker', + '[ + {"name": "label", "value": "Datepicker"} + ]', + '{ + "isRequired": false, + "custom": null + }', + '2024-08-30T09:50:31.926Z', + '2024-08-30T09:50:31.926Z' +); diff --git a/src/main/resources/db/dump/updated_form_field_data_16-09-2024.sql b/src/main/resources/db/dump/updated_form_field_data_16-09-2024.sql new file mode 100644 index 00000000..1855bfe5 --- /dev/null +++ b/src/main/resources/db/dump/updated_form_field_data_16-09-2024.sql @@ -0,0 +1,91 @@ +INSERT INTO FORM_FIELD (SORT_ORDER, NAME, LABEL, DESCRIPTION, SETTINGS, VALIDATORS, CREATED_DATE, UPDATED_DATE) +VALUES +(1, 'textinput', 'Testo Breve', 'Per risposte concise (nomi, titoli, brevi descrizioni)', + '[{"name": "label", "value": "Testo Breve"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(2, 'textarea', 'Testo Lungo', 'Campo di testo esteso per paragrafi, descrizioni, proposte', + '[{"name": "label", "value": "Testo Lungo"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(3, 'wysiwyg', 'Campo di Testo Formattato', 'Editor avanzato per testo con formattazione', + '[{"name": "label", "value": "Testo Formattato"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(4, 'numberinput', 'Campo Numerico', 'Per l''inserimento di valori numerici (quantità, importi, percentuali)', + '[{"name": "label", "value": "Numero"}, {"name": "placeholder", "value": "0"}, {"name": "step", "value": "0"}]', + '{"isRequired": false, "min": null, "max": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(5, 'radio', 'Scelta Singola', 'Gruppo di opzioni per selezione singola', + '[{"name": "label", "value": "Scelta Singola"}, {"name": "options", "value": "[]"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(6, 'select', 'Menu a Tendina', 'Selezione da opzioni predefinite', + '[{"name": "label", "value": "Menu a Tendina"}, {"name": "options", "value": "[]"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(7, 'checkboxes', 'Scelta Multipla', 'Gruppo di opzioni per selezione singola o multipla', + '[{"name": "label", "value": "Scelta Multipla"}, {"name": "options", "value": "[]"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(8, 'switch', 'Casella di Spunta', 'Per selezioni binarie, accettazioni, conferme', + '[{"name": "label", "value": "Casella di Spunta"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(9, 'datepicker', 'Data', 'Selezione di data', + '[{"name": "label", "value": "Data"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(10, 'fileupload', 'Caricamento File', 'Per l''upload di documenti o immagini', + '[{"name": "label", "value": "Caricamento File"}, {"name": "mime", "value": "[]"}]', + '{"isRequired": false, "maxSize": 100000, "pattern": null, "custom": null}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(11, 'textinput', 'Campo Partita IVA', 'Specifico per l''inserimento del numero di Partita IVA', + '[{"name": "label", "value": "Partita IVA"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": true, "pattern": null, "custom": "isPIVA"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(12, 'textinput', 'Campo Codice Fiscale', 'Specifico per l''inserimento del Codice Fiscale italiano per persone fisiche e giuridiche', + '[{"name": "label", "value": "Codice Fiscale"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": true, "pattern": null, "custom": "isCodiceFiscale"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(13, 'numberinput', 'Campo CAP', 'Per l''inserimento del Codice di Avviamento Postale', + '[{"name": "label", "value": "CAP"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": true, "minLength": null, "maxLength": null, "pattern": null, "custom": "isCAP"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(14, 'textinput', 'Campo IBAN', 'Per l''inserimento del codice IBAN', + '[{"name": "label", "value": "IBAN"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": true, "minLength": null, "maxLength": null, "pattern": null, "custom": "isIBAN"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(15, 'textinput', 'Campo Email', 'Per l''inserimento di indirizzi email standard (non PEC)', + '[{"name": "label", "value": "Campo Email"}, {"name": "placeholder", "value": "nome@esempio.it"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": "isEmail"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(16, 'textinput', 'Campo PEC', 'Specifico per l''inserimento di un indirizzo di Posta Elettronica Certificata', + '[{"name": "label", "value": "Campo PEC"}, {"name": "placeholder", "value": "nome@pec.it"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": "isEmailPEC"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(17, 'textinput', 'Campo URL', 'Per l''inserimento di indirizzi web', + '[{"name": "label", "value": "Indirizzo URL"}, {"name": "placeholder", "value": ""}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": "isUrl"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP), + +(18, 'textinput', 'Marca da bollo', 'Per inserire codice di marca da bollo', + '[{"name": "label", "value": "Marca da bollo"}, {"name": "placeholder", "value": "Numero identificativo"}]', + '{"isRequired": false, "minLength": null, "maxLength": null, "pattern": null, "custom": "isMarcaDaBollo"}', + CURRENT_TIMESTAMP, CURRENT_TIMESTAMP); diff --git a/src/main/resources/dev/saml/idp-certificate.pem b/src/main/resources/dev/saml/idp-certificate.pem new file mode 100644 index 00000000..598749d1 --- /dev/null +++ b/src/main/resources/dev/saml/idp-certificate.pem @@ -0,0 +1,3 @@ +-----BEGIN CERTIFICATE----- +MIIDJDCCAgygAwIBAgIVAIq/MUgxPKO0cuX/GtD7YUvk87GtMA0GCSqGSIb3DQEBBQUAMBkxFzAVBgNVBAMTDmlkcC5tYWNoaW5lLml0MB4XDTA5MDMyNTEwNTM1OFoXDTI5MDMyNTA5NTM1OFowGTEXMBUGA1UEAxMOaWRwLm1hY2hpbmUuaXQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQClXV18x0/yhZ+D3pHlmhrK4paA+xdJKAT7U7R9DeaTQygwtCjKmCrJbzdohckLz5pax7eaGeA53pPCY+JdiU0Uq4ES8nG2DCZgCtl4QGLUcTuUtJdPq+DbYD1cWBwEeeffsiClVyuhgLRPO1OQLl/TJp4slfoYTi0aONgQp03uG+ixL48myL7GrINHYXtDUDqo2BimyU0yrOe6ZmvxJchZ8nBuWKy0J8wsO/Mnasbvo79/c8gcn0HTst0QDlHXQlzwZ4Suq2os9qKjXAYOzA1VqmTyzJIge/ynHiJ0Fkw0HNxBaVFTJRNL8RvwJsMuBT7YZKRoNK7gjT5/6bGagYM/AgMBAAGjYzBhMEAGA1UdEQQ5MDeCDmlkcC5tYWNoaW5lLml0hiVodHRwczovL2lkcC5tYWNoaW5lLml0L2lkcC9zaGliYm9sZXRoMB0GA1UdDgQWBBSBOsPZiWZRXFqNINIguHfv7jnidDANBgkqhkiG9w0BAQUFAAOCAQEAeVLN9jczRINuPUvpXbgibL2c99dUReMcl47nSVtYeYEBkPPZrSz0h3AyVZyar2Vo+/fC3fRNmaOJvfiVSm+bo1069iROI1+dGGq2gAwWuQI1q0F7PNPX4zooY+LbZI0oUhuoyH81xed0WtMlpJ1aRSBMpR6oV3rguAkH6pdr725yv6m5WxKcOM/LzdD5Xt9fQRL7ino4HfiPPJNDG3UOKhoAWkVn/Y/CuMLcBPWh/3LxIv4A1bQbnkpdty+Qtwfp4QUKkisv7gufQP91aLqUvvRE6Uz8r51VH13e4mEJjJGxLKXWzlP50gp7b27AXCTKSS6fW6iBpfA14PGcWvDiPQ== +-----END CERTIFICATE----- diff --git a/src/main/resources/dev/saml/private-key.pem b/src/main/resources/dev/saml/private-key.pem new file mode 100644 index 00000000..9302e091 --- /dev/null +++ b/src/main/resources/dev/saml/private-key.pem @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCsCrXQyDN5nURj +2LB1wJKRIOzO8tgIXxPHVL65dYv7cOql01b5LpmUGQaGfUKALlvEdPs0NwCSdiyz +MGAMTD81KHLqa+Wdm5ySl82ONRGl15pmHQFJlUDFpOr5+r1AZvQdh9MfdcbWW57m +4qaDEF3kvihIZg9PMbqlQjHOrcG1iUPzpHnzcnmevpP32MH2FSYZhy+b0Ie2Fsho +3Aj7CvmJYlBWfCaFLQ/wi8FsDEhjsOlUUkcr7/giO3ygK57oPzcld74g4x79A/UH +VbUe2+CUxzFqP9+VtDWGqJ7lp0bHA/lfGvmDvIJAY6UDyYfum1Vn/ag2NmvW5wLH +Z8vdLP75AgMBAAECggEABJ5u/jF5zFCQFvwo1Kh8ZuAS64Vyjlr7HXVlf3Yr8W65 +JgWUBrGdFvBLEA5J3EYiWZZobiDx53y7u33Xfk0Hv2YcG7YU3pPgcsEXmDNNi33L +2+T4dWDH8eZ5FogIT7PT5v0QCn6vfW7NR9aa8NbeJneCflsbGx2zLJ+n1awtkLGY +6vFSwl/xzRCClWCccT64+8/b2btLEDFa4IK5KdMoiP/t1fM51vu3DmPBgWt2ZWH1 +cPcd2GSXPaEyHECUAYV7/HpY5I+2xD8W3YJLaGmSeavsuW726ygUaYDsX3L3EPP8 +/AIPwhI0uLRLT2zRfH9BzPqJL+A1gnFR/BysVWnKQQKBgQDm6myujHrpe1A92j8v +E3nTmaigCAdIhJSkoOjcvHxcHacJtK/QN4zmQvOtHwn9NAOz0jvMgJUM2Pd6t4MV +1vWSFZam9P6EkNkmhg94V2FnQlas329XIfLWdVqfVsTxbyhIICRLBmBgn3Z22ugw +FU5rYoZw7mjP/Gqhv3hYNH2dcQKBgQC+uw01Jh51JclSkT2lh5M2xwovnA74HuWT +d/w9smXS3hi1TJn0ECVJKagZXhwAIgVntxzV93Vz3++VvX3LeM81eOD2vTpTR+MP +mZ8lwsCxKDABZfoFV79lrO+8I61e4pSgcRSK0uqsvFmlN1agL+hn6esBrZe4IV37 +Hvk1OobWCQKBgFtJ8B9tcCYf1xAs2O/Ofko2JCDoK6DysSUIbCbf6TYtjtzabusd +GvnpHBaj/7n3N0N+6J8nckV6/ROpuwwGSF0xZbapgnl8Hi0JsNH9kYdWBZggWQ8U +X8GC8YmurvtX24/wDQkQA0gPorDISCTCN5digw3gYtVez/UUEgqk7cgxAoGADA3q +YceM+T5wIOXJDaMp7LZbsHKeh5P8Unus14Fk6hTbXun+eOxkTuFxHFlUT7XWvZ1X +FzbSl4Y5sC8PukJiZjDDlxSSkRzj/uJoqoxKfWfa0NvPF3NaR2TMqglfNbYASrua +3sNBzbUBvW1n7ivY9mhUUADWq+5/8BUfDvwp9XECgYEAxfclKcPbns4Hm5N0/tGV +aTCvlwXIWIYa5krewof1bfW/APS917MZEfIMvVUJOtLU+iD9OJnZOMtA3qFDcWN6 +gnkQui8RpmJKteLf2eemfP6owWhMG5AZZjcinLTjHbiWFnjs8HLsj8931pGxSSUD +aR7D9CcLcEUqi8EaeNukmbA= +-----END PRIVATE KEY----- diff --git a/src/main/resources/dev/saml/public-cert.pem b/src/main/resources/dev/saml/public-cert.pem new file mode 100644 index 00000000..b88d60cb --- /dev/null +++ b/src/main/resources/dev/saml/public-cert.pem @@ -0,0 +1,24 @@ +-----BEGIN CERTIFICATE----- +MIID+zCCAuOgAwIBAgIUBKj5WxwQRn0Ro0lChsMb+NZOnTMwDQYJKoZIhvcNAQEL +BQAwgYwxCzAJBgNVBAYTAklUMQ8wDQYDVQQIDAZVbWJyaWExEDAOBgNVBAcMB1Bl +cnVnaWExEDAOBgNVBAoMB0dlcGFmaW4xCzAJBgNVBAsMAklUMRAwDgYDVQQDDAdH +ZXBhZmluMSkwJwYJKoZIhvcNAQkBFhpyaW5hbGRvLmJvbmF6em9AYmZsb3dzLm5l +dDAeFw0yNDA5MjMwODUxMTlaFw0yNTA5MjMwODUxMTlaMIGMMQswCQYDVQQGEwJJ +VDEPMA0GA1UECAwGVW1icmlhMRAwDgYDVQQHDAdQZXJ1Z2lhMRAwDgYDVQQKDAdH +ZXBhZmluMQswCQYDVQQLDAJJVDEQMA4GA1UEAwwHR2VwYWZpbjEpMCcGCSqGSIb3 +DQEJARYacmluYWxkby5ib25henpvQGJmbG93cy5uZXQwggEiMA0GCSqGSIb3DQEB +AQUAA4IBDwAwggEKAoIBAQCsCrXQyDN5nURj2LB1wJKRIOzO8tgIXxPHVL65dYv7 +cOql01b5LpmUGQaGfUKALlvEdPs0NwCSdiyzMGAMTD81KHLqa+Wdm5ySl82ONRGl +15pmHQFJlUDFpOr5+r1AZvQdh9MfdcbWW57m4qaDEF3kvihIZg9PMbqlQjHOrcG1 +iUPzpHnzcnmevpP32MH2FSYZhy+b0Ie2Fsho3Aj7CvmJYlBWfCaFLQ/wi8FsDEhj +sOlUUkcr7/giO3ygK57oPzcld74g4x79A/UHVbUe2+CUxzFqP9+VtDWGqJ7lp0bH +A/lfGvmDvIJAY6UDyYfum1Vn/ag2NmvW5wLHZ8vdLP75AgMBAAGjUzBRMB0GA1Ud +DgQWBBTSz8YB9ACNsuoGwrhtGt4ct+Bm3DAfBgNVHSMEGDAWgBTSz8YB9ACNsuoG +wrhtGt4ct+Bm3DAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAB +3xJ2OQBI4VgICN4ohZ+Bfq4pHkJgZUV202mC8XLiCx1oihpi1ew25zu5BdNUgDn8 +dlMzx8MeMa4aRCKg5Xdio956ea1iPx4n0UafbnU13p2oLGTSDKRuYOidDcFF/fl4 +77nVAa8THc9GKaIQ1jvOnZ5+Sq0dKA2ZjT4sXciuEgrdsPM5CSjHNSSN9dwceGVZ +OWyta0NViqQh1DFfLv1Tqkt3vaEcKRGqWlXryHmRSlmTrAiTFF4LE4eYMiUrlIbq +P4R1R0w7fVXRufJkpiTAzrmQa5xTr5/9w8zTDuFxVHAQ23vMn9uB+P4ZUDu6ZoDP +khKe3VzuKIBSKiSfiuFY +-----END CERTIFICATE----- diff --git a/src/main/resources/message_en.properties b/src/main/resources/message_en.properties new file mode 100644 index 00000000..cf80165c --- /dev/null +++ b/src/main/resources/message_en.properties @@ -0,0 +1,196 @@ +user.created.success=User created successfully. +user.updated.success=User updated successfully. +user.deleted.success=User deleted successfully. +user.not.found=User not found. +create_user_error_msg=An error occurred while creating the user. +update_user_error_msg=An error occurred while updating the user. +delete_user_error_msg=An error occurred while deleting the user. +get_user_success_msg=User retrieved successfully. +get_user_error_msg=An error occurred while retrieving the user. +user.not.active=User is not active. Please contact support. +user.already.exist.msg=User already exist for this codice fiscale. +validate.email=The email is mandatory and must be in the correct format. Please verify and try again. +validate.password=The password and confPassword are mandatory. Please verify and try again. +# Role-related messages +role.created.success=Role created successfully. +role.updated.success=Role updated successfully. +role.deleted.success=Role deleted successfully. +role.not.found=Role not found. +create.role.error=Error occurred while creating the role. +update.role.error=Error occurred while updating the role. +role.fetch.success=Role fetched successfully. +delete.role.error=Error occurred while deleting the role. +role.id.mandatory=Role id is mandatory. + +# Region-related messages +region.created.success=Region created successfully. +region.updated.success=Region updated successfully. +get.region.success=Region fetched successfully. +delete.region.success=Region deleted successfully. +user.region.not.found=Region not found. +create.regiom.error=Error occurred while creating the region. +update.region.error=Error occurred while updating the region. +password.doesnt.match=Password and confirm password do not match. + +#call related messages +user.not.exist=User does not exist. +region.not.found=Region not found. +user.id.not.null=User ID cannot be null. +question.not.empty=Question cannot be empty. +name.not.empty=Name cannot be empty. +type.not.empty=Type cannot be empty. +region.not.null=Region ID cannot be null. +amount.greater.than.zero=Amount must be greater than zero. +look.up.data.not.valid=Look up data entity is not valid. +files.uploaded=Files uploaded successfully. +call.created.successfully=Call created successfully. +file.deleted.successfully=File deleted successfully. +document.not.found=Document not found. +document.id.not.found=Document ID not found. +call.invalid.date=Invalid start or end date. +call.id.not.null=Call id cannot be null. +call.update.successfully=Call updated successfully. +call.fetch.success=Call details fetched successfully. +call.not.found=Call not found. +score.not.null=Score cannot be null or cannot be zero. +field.not.null={0} cannot be null. +field.not.empty={0} cannot be empty. +update_call_status_success_msg=The call status has been updated successfully. +status.same.error=Status is already set. +invalid.status.change.from.draft=Status cannot be changed to READY_TO_PUBLISH or PUBLISH from DRAFT. +status.cannot.be.changed=Status cannot be changed. +published.call.not.update=Published call cannot be updated. +invalid.status.change.from.publish=Status cannot be changed to READY_TO_PUBLISH or DRAFT from PUBLISH. + + + +# Login-related messages +login.successfully=Login successfully. +pass.min.len.msg=Password must be at least 8 characters long. +email.already.exists=A user with this email already exists. +invalid_user=User validation failed. Check user info, account status, and token expiration. + +#Global messages +common_message=Something went wrong..Please try again.. +invalid_signature=Invalid token. +invalid_login=Invalid username or password. +req_validation_er=Request Validation Error + +#Form-related messages +form.not.found=Form not found. +form.created.successfully=Form created successfully. +form.updated.suucessfully=Form updated successfully. +form.deleted.successfully=Form deleted successfully. +form.fetched.successfully=Form fetched successfully. +required.parameter.not.found.for.form=Label or content cannot be null. +form.not.found.for.call.id=Form not found for corresponding call. +#EvaluationCriteria-related messages +evaluation.criteria.not.found=EvaluationCriteria not found. +evaluation.criteria.created.successfully=EvaluationCriteria created successfully. +evaluation.criteria.fetch.successfully=EvaluationCriteria fetched successfully. +evaluation.criteria.updated.successfully=EvaluationCriteria updated successfully. +evaluation.criteria.deleted.successfully=EvaluationCriteria deleted successfully. +# Password reset messages +password.reset.initiated=Password reset initiated. +password.reset.success=Password has been successfully reset. +#Change Password +invalid.token.msg=The token provided is invalid or expired. Please request a new token. +current.password.incorrect = Current password is incorrect. +success.password.changed=Password changed successfully. +#Logout +logout.successful.msg=Logout successful. You have been logged out successfully. +#Update user Active or Deactive status +update.user.status.success=User status has been successfully updated. + + +#Form-field-related messages +form.field.not.found=Form field not found. +form.field.created.successfully=Form field created successfully. +form.field.updated.suucessfully=Form field updated successfully. +form.field.deleted.successfully=Form field deleted successfully. +form.field.fetched.successfully=Form field fetched successfully. +required.parameter.not.found.for.form.field=Label or definition cannot be null. + + +#Form-template-related messages +form.template.not.found=Form template not found. +form.template.created.successfully=Form template created successfully. +form.template.updated.suucessfully=Form template updated successfully. +form.template.deleted.successfully=Form template deleted successfully. +form.template.fetched.successfully=Form template fetched successfully. +required.parameter.not.found.for.form.template=Label or content cannot be null. +#Faq-related messages +faq.not.found=Faq not found. +faq.created.successfully=Faq created successfully. +faq.fetched.successfully=Faq fetched successfully. +faq.updated.successfully=Faq updated successfully. +faq.deleted.successfully=Faq deleted successfully. + +#LookUpData-related message +lookupdata.not.found=LookUpData not found. +lookupdata.created.successfully=LookUpData created successfully. +lookupdata.fetched.successfully=LookUpData fetched successfully. +lookupdata.updated.successfully=LookUpData updated successfully. +lookupdata.deleted.successfully=LookUpData deleted successfully. +lookupdata.value.cannot.be.empty=Value field cannot be empty + +#Document-related message +document.updated.successfully=Document updated successfully. +document.fetched.successfully=Document fetched successfully. + +#Flow-related message +flow.created.successfully=Flow created successfully. +flow.fetched.successfully=Flow fetched successfully. +flow.already.exists= Flow already exist for this call. +flow.request.not.complete=Flow request is not complete. +initial.and.final.form.cannot.null=Initial and final form cannot be null. + +# Application related messages +application.created.success=Application successfully created. +application.updated.success=Application successfully updated. +application.deleted.success=Application successfully deleted. +application.get.success=Application details fetched successfully. +application.not.found=Application not found with the given ID. +application.form.field.not.found=Application form field not found. +Form.not.matches.to.call.initial.form=Form id does not matches to initial form id of call. +application.already.exists=Application already exists for this call. +application.already.submitted=Application is already submitted. + +#Validation related messages +validation.field.required=Field {0} is required. +validation.field.min_length=Field {0} must be at least {1} characters long. +validation.field.max_length=Field {0} must be no more than {1} characters long. +validation.field.pattern=Field {0} does not match the required pattern. +validation.field.not_null=Field {0} must not be null. +validation.field.not_empty=Field {0} must not be empty. + +current.form.incomplete=Current form is not filled. +flow.not.found=Flow not found. +validation.message=Validation messages. +action.required=Action field required. +call.not.published=Call is not published. +application.form.not.found=Application form not found. + +updating.form.value.impact.on.flow=Updating this value of form {0} can make impact on flow. +validation.field.custom=The value for field {0} does not meet the custom validation rule. + +validation.codice.fiscale=The field {0} must be a valid Codice Fiscale with exactly 16 characters: 6 letters, 2 digits, 1 letter, 2 digits, 1 letter, 3 digits, and 1 letter. +validation.cap=The field {0} must be a valid CAP with exactly 5 digits. +validation.iban=The field {0} must be a valid IBAN with exactly 27 characters. +validation.email=The field {0} must be a valid email address. +validation.email.pec=The field {0} must be a valid PEC email address. +validation.url=The field {0} must be a valid URL. +validation.marca.da.bollo=The field {0} must be a valid Marca Da Bollo with exactly 14 digits. +validation.piva=The VAT number for {0} must be up to 11 digits. +valid.vat.number=The VAT number is not valid for field {0}. + + +failed.retain.field=Failed to retain specific fields. + +application.is.incomplete = The application is incomplete. +token.validate.success=Token validated successfully. +invalid.request=Invalid Request. +codice.fiscale.exists=This codice fiscale is already associated with another user. +total.steps.not.zero=Total steps cannot be zero. +completed.steps.not.valid=Completed steps should be between 0 and total steps. +field.id.not.found=Field ID {0} does not exist in the form structure. diff --git a/src/main/resources/message_it.properties b/src/main/resources/message_it.properties new file mode 100644 index 00000000..9582a89d --- /dev/null +++ b/src/main/resources/message_it.properties @@ -0,0 +1,189 @@ +user.created.success=Utente creato con successo. +user.updated.success=Utente aggiornato con successo. +user.deleted.success=Utente eliminato con successo. +user.not.found=Utente non trovato. +create_user_error_msg=Si � verificato un errore durante la creazione dell'utente. +update_user_error_msg=Si � verificato un errore durante l'aggiornamento dell'utente. +delete_user_error_msg=Si � verificato un errore durante l'eliminazione dell'utente. +get_user_success_msg=Utente recuperato con successo. +get_user_error_msg=Si � verificato un errore durante il recupero dell'utente. +user.not.active=Utente non attivo. Si prega di contattare il supporto. +user.already.exist.msg=L'utente esiste gi� per questo codice fiscale. +validate.email=L'email è obbligatoria e deve essere nel formato corretto. Si prega di verificare e riprovare. +validate.password=La password e confPassword sono obbligatorie. Verifica e riprova. +# Role-related messages +role.created.success=Ruolo creato con successo. +role.updated.success=Ruolo aggiornato con successo. +role.deleted.success=Ruolo eliminato con successo. +role.not.found=Ruolo non trovato. +create.role.error=Errore durante la creazione del ruolo. +update.role.error=Errore durante l'aggiornamento del ruolo. +role.fetch.success=Ruolo recuperato con successo. +delete.role.error=Errore durante l'eliminazione del ruolo. +role.id.mandatory=L'ID del ruolo è obbligatorio. + +# Region-related messages +region.created.success=Regione creata con successo. +region.updated.success=Regione aggiornata con successo. +get.region.success=Regione recuperata con successo. +delete.region.success=Regione eliminata con successo. +user.region.not.found=Regione non trovata. +create.regiom.error=Errore durante la creazione della regione. +update.region.error=Errore durante l'aggiornamento della regione. +password.doesnt.match=La password e la conferma della password non corrispondono. + +#call related messages +user.not.exist=L'utente non esiste. +region.not.found=Regione non trovata. +user.id.not.null=L'ID utente non pu� essere nullo. +question.not.empty=La domanda non pu� essere vuota. +name.not.empty=Il nome non pu� essere vuoto. +type.not.empty=Il tipo non pu� essere vuoto. +region.not.null=L'ID regione non pu� essere nullo. +amount.greater.than.zero=L'importo del finanziamento deve essere maggiore di zero. +look.up.data.not.valid=L'entit� dati di ricerca non � valida. +files.uploaded=File caricati correttamente. +call.created.successfully=Chiamata creata correttamente. +file.deleted.successfully=File eliminato con successo. +document.not.found=Documento non trovato. +document.id.not.found=ID documento non trovato. +call.invalid.date=Data di inizio o fine non valida. +call.id.not.null=L'ID della chiamata non pu� essere nullo. +call.update.successfully=Chiamata aggiornata con successo. +call.fetch.success=Dettagli della chiamata recuperati con successo. +call.not.found=Chiamata non trovata. +score.not.null=Il punteggio non pu� essere nullo o zero. +field.not.null={0} non pu� essere nullo. +field.not.empty=la {0} non pu� essere vuota. +update_call_status_success_msg=Lo stato della chiamata � stato aggiornato con successo. +status.same.error=Lo stato � gi� impostato. +invalid.status.change.from.draft=Lo stato non pu� essere cambiato in READY_TO_PUBLISH o PUBLISH da DRAFT. +status.cannot.be.changed=Lo stato non pu� essere cambiato. +published.call.not.update=Il bando pubblicato non pu� essere aggiornato. +invalid.status.change.from.publish=Lo stato non pu� essere modificato in READY_TO_PUBLISH o DRAFT da PUBLISH. + + +# Login-related messages +login.successfully=Accesso effettuato con successo. +pass.min.len.msg=La password deve essere lunga almeno 8 caratteri. +email.already.exists=Esiste gi� un utente con questa email. +invalid_user=Validazione utente fallita. Controlla le informazioni, lo stato dell'account e la scadenza del token. + +#Global messages +common_message=qualcosa é andato storto. Per favore riprova +invalid_signature=Gettone non valido. +invalid_login=Nome utente o password errati +req_validation_er=Errore di convalida + +#Form-related messages +form.not.found=Modulo non trovato. +form.created.successfully=Modulo creato correttamente. +form.updated.suucessfully=Modulo aggiornato correttamente. +form.deleted.successfully=Modulo eliminato correttamente. +form.fetched.successfully=Modulo recuperato correttamente. +required.parameter.not.found.for.form=L'etichetta o il contenuto non possono essere nulli. +form.not.found.for.call.id=Modulo non trovato per la chiamata corrispondente. + +#Form-field-related messages +form.field.not.found=Campo modulo non trovato. +form.field.created.successfully=Campo del modulo creato correttamente. +form.field.updated.suucessfully=Campo del modulo aggiornato correttamente. +form.field.deleted.successfully=Campo del modulo eliminato correttamente. +form.field.fetched.successfully=Campo del modulo recuperato correttamente. +required.parameter.not.found.for.form.field=Etichetta o definizione non possono essere nulli. + +#Form-template-related messages +form.template.not.found=Modello di modulo non trovato. +form.template.created.successfully=Modello di modulo creato correttamente. +form.template.updated.suucessfully=Modello di modulo aggiornato correttamente. +form.template.deleted.successfully=Modello di modulo eliminato correttamente. +form.template.fetched.successfully=Modello di modulo recuperato correttamente. +required.parameter.not.found.for.form.template=Etichetta o contenuto non possono essere nulli. +#EvaluationCriteria-related messages +evaluation.criteria.not.found=EvaluationCriteria non trovato. +evaluation.criteria.created.successfully=EvaluationCriteria creato con successo. +evaluation.criteria.fetch.successfully=Recupero EvaluationCriteria riuscito. +evaluation.criteria.updated.successfully=EvaluationCriteria aggiornato con successo. +evaluation.criteria.deleted.successfully=EvaluationCriteria eliminato con successo. + +#faq-related messages +faq.not.found=Faq non trovata. +faq.created.successfully=Faq creata con successo. +faq.fetched.successfully=Faq recuperata con successo. +faq.updated.successfully=Faq aggiornata con successo. +faq.deleted.successfully=Faq eliminata con successo. + +#LookUpData-related message +lookupdata.not.found=LookUpData non trovato. +lookupdata.created.successfully=LookUpData creato correttamente. +lookupdata.fetched.successfully=LookUpData recuperato correttamente. +lookupdata.updated.successfully=LookUpData aggiornato correttamente. +lookupdata.deleted.successfully=LookUpData eliminato correttamente. +lookupdata.value.cannot.be.empty=Il campo valore non pu� essere vuoto + +#Document-related message +document.updated.successfully=Documento aggiornato con successo. +document.fetched.successfully=Documento recuperato con successo. +# Password reset messages +password.reset.initiated=Reimpostazione della password avviata. +password.reset.success=La password � stata reimpostata con successo. +invalid.token.msg=Il token fornito � invalido o scaduto. Si prega di richiedere un nuovo token. +current.password.incorrect = La password attuale non � corretta. +success.password.changed=Password cambiata con successo. +logout.successful.msg=Logout riuscito. Sei stato disconnesso con successo. + +update.user.status.success=Lo stato dell'utente � stato aggiornato con successo. + +#Flow-related message +flow.created.successfully=Flusso creato con successo. +flow.fetched.successfully=Flusso recuperato con successo. +flow.already.exists= Il flusso esiste gi� per questa chiamata. +flow.request.not.complete=La richiesta di flusso non � completa. +initial.and.final.form.cannot.null=La forma iniziale e finale non possono essere nulle. + +# Application related messages +application.created.success=Applicazione creata con successo. +application.updated.success=Applicazione aggiornata con successo. +application.deleted.success=Applicazione eliminata con successo. +application.get.success=Dettagli dell'applicazione recuperati con successo. +application.not.found=Applicazione non trovata con l'ID fornito. +application.form.field.not.found=Campo del modulo di domanda non trovato. +Form.not.matches.to.call.initial.form=L'ID del modulo non corrisponde all'ID del modulo iniziale della chiamata. +application.already.exists=L'applicazione esiste gi� per questa chiamata. +application.already.submitted=La domanda � gi� stata inviata. + +#Validation related messages +validation.field.required=Il campo {0} � obbligatorio. +validation.field.min_length=Il campo {0} deve essere lungo almeno {1} caratteri. +validation.field.max_length=Il campo {0} deve essere lungo al massimo {1} caratteri. +validation.field.pattern=Il campo {0} non corrisponde al modello richiesto. +validation.field.not_null=Il campo {0} non deve essere nullo. +validation.field.not_empty=Il campo {0} non deve essere vuoto. +current.form.incomplete=il modulo corrente non � compilato +flow.not.found=Flow not found. +validation.message=Messaggi di convalida. +action.required=Campo azione obbligatorio. +call.not.published=La chiamata non � stata pubblicata. +application.form.not.found=Modulo di domanda non trovato. + +application.is.incomplete = L'applicazione � incompleta. +updating.form.value.impact.on.flow=L'aggiornamento di questo valore del modulo {0} pu� avere un impatto sul flusso. +validation.field.custom=Il valore per il campo {0} non soddisfa la regola di convalida personalizzata. + +validation.codice.fiscale=Il campo {0} deve essere un Codice Fiscale valido con esattamente 16 caratteri: 6 lettere, 2 cifre, 1 lettera, 2 cifre, 1 lettera, 3 cifre e 1 lettera. +validation.cap=Il campo {0} deve essere un CAP valido con esattamente 5 cifre. +validation.iban=Il campo {0} deve essere un IBAN valido con esattamente 27 caratteri. +validation.email=Il campo {0} deve essere un indirizzo email valido. +validation.email.pec=Il campo {0} deve essere un indirizzo email PEC valido. +validation.url=Il campo {0} deve essere un URL valido. +validation.marca.da.bollo=Il campo {0} deve essere una Marca Da Bollo valida con esattamente 14 cifre. +validation.piva=Il numero di partita IVA per {0} deve essere lungo fino a 11 cifre. +valid.vat.number=Il numero di partita IVA non � valido per il campo {0}. +failed.retain.field=Impossibile conservare campi specifici. +token.validate.success=Token convalidato con successo. +invalid.request=Richiesta non valida. +codice.fiscale.exists=Questo codice fiscale � gi� associato ad un altro utente. + +total.steps.not.zero=Il totale dei passaggi non pu� essere zero. +completed.steps.not.valid=I passaggi completati devono essere compresi tra 0 e il totale dei passaggi. +field.id.not.found=L'ID campo {0} non esiste nella struttura del modulo. diff --git a/src/test/java/net/gepafin/tendermanagement/TendermanagementApplicationTests.java b/src/test/java/net/gepafin/tendermanagement/TendermanagementApplicationTests.java new file mode 100644 index 00000000..6c53e258 --- /dev/null +++ b/src/test/java/net/gepafin/tendermanagement/TendermanagementApplicationTests.java @@ -0,0 +1,13 @@ +package net.gepafin.tendermanagement; + +import org.junit.jupiter.api.Test; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest +class TendermanagementApplicationTests { + + @Test + void contextLoads() { + } + +}