wxc 1 year ago
commit
f92cb97999
  1. 33
      .gitignore
  2. 19
      .mvn/wrapper/maven-wrapper.properties
  3. 1978
      demo.json
  4. 259
      mvnw
  5. 149
      mvnw.cmd
  6. 184
      pom.xml
  7. 2
      sql/0911.sql
  8. 83
      sql/data.sql
  9. 25
      sql/dict.sql
  10. 8
      sql/file_class.sql
  11. 548
      sql/negative_0904.sql
  12. 8
      sql/negative_mark.sql
  13. 89
      sql/open-platform_0904.sql
  14. 4
      sql/truncate.sql
  15. 1
      sql/update-data.sql
  16. 15
      src/main/java/com/biutag/supervision/SupervisionApplication.java
  17. 34
      src/main/java/com/biutag/supervision/common/UserContextHolder.java
  18. 20
      src/main/java/com/biutag/supervision/config/FastDFSConfig.java
  19. 62
      src/main/java/com/biutag/supervision/config/GlobalExceptionHandler.java
  20. 68
      src/main/java/com/biutag/supervision/config/InterceptorConfig.java
  21. 22
      src/main/java/com/biutag/supervision/config/MybatisPlusConfig.java
  22. 28
      src/main/java/com/biutag/supervision/config/SwaggerConfig.java
  23. 26
      src/main/java/com/biutag/supervision/constants/AppConstants.java
  24. 6
      src/main/java/com/biutag/supervision/constants/RedisKeyConstants.java
  25. 17
      src/main/java/com/biutag/supervision/constants/enums/ApprovalFlowEnum.java
  26. 7
      src/main/java/com/biutag/supervision/constants/enums/ApproveStateEnum.java
  27. 35
      src/main/java/com/biutag/supervision/constants/enums/BusinessTypeEnum.java
  28. 16
      src/main/java/com/biutag/supervision/constants/enums/DepartLevelEnum.java
  29. 19
      src/main/java/com/biutag/supervision/constants/enums/FlowActionEnum.java
  30. 41
      src/main/java/com/biutag/supervision/constants/enums/FlowNodeEnum.java
  31. 15
      src/main/java/com/biutag/supervision/constants/enums/HostLevelEnums.java
  32. 28
      src/main/java/com/biutag/supervision/constants/enums/InspectCaseEnum.java
  33. 16
      src/main/java/com/biutag/supervision/constants/enums/IsRectifyEnum.java
  34. 17
      src/main/java/com/biutag/supervision/constants/enums/MenuEnum.java
  35. 33
      src/main/java/com/biutag/supervision/constants/enums/ProblemSourcesEnum.java
  36. 11
      src/main/java/com/biutag/supervision/constants/enums/ProcessingStatusEnum.java
  37. 17
      src/main/java/com/biutag/supervision/constants/enums/RoleCodeEnum.java
  38. 15
      src/main/java/com/biutag/supervision/constants/enums/StatusEnum.java
  39. 38
      src/main/java/com/biutag/supervision/constants/enums/TimeLimitEnum.java
  40. 7
      src/main/java/com/biutag/supervision/constants/enums/WorkStateEnum.java
  41. 7
      src/main/java/com/biutag/supervision/constants/enums/WorkStatusEnum.java
  42. 76
      src/main/java/com/biutag/supervision/controller/AuthController.java
  43. 56
      src/main/java/com/biutag/supervision/controller/FileController.java
  44. 64
      src/main/java/com/biutag/supervision/controller/LoginController.java
  45. 157
      src/main/java/com/biutag/supervision/controller/StatisticsController.java
  46. 49
      src/main/java/com/biutag/supervision/controller/api/jwdc/NegativeApiController.java
  47. 30
      src/main/java/com/biutag/supervision/controller/api/plugin/PetitionComplainApiController.java
  48. 10
      src/main/java/com/biutag/supervision/controller/data/DataController.java
  49. 26
      src/main/java/com/biutag/supervision/controller/sensitivePerception/ModelClassController.java
  50. 47
      src/main/java/com/biutag/supervision/controller/sensitivePerception/ModelController.java
  51. 82
      src/main/java/com/biutag/supervision/controller/system/DepartController.java
  52. 52
      src/main/java/com/biutag/supervision/controller/system/DictContentController.java
  53. 74
      src/main/java/com/biutag/supervision/controller/system/DictController.java
  54. 46
      src/main/java/com/biutag/supervision/controller/system/MenuController.java
  55. 70
      src/main/java/com/biutag/supervision/controller/system/PoliceController.java
  56. 60
      src/main/java/com/biutag/supervision/controller/system/RoleController.java
  57. 30
      src/main/java/com/biutag/supervision/controller/system/UserController.java
  58. 25
      src/main/java/com/biutag/supervision/controller/work/FlowNodeController.java
  59. 49
      src/main/java/com/biutag/supervision/controller/work/NegativeController.java
  60. 43
      src/main/java/com/biutag/supervision/controller/work/NegativeFavController.java
  61. 31
      src/main/java/com/biutag/supervision/controller/work/WorkController.java
  62. 4
      src/main/java/com/biutag/supervision/exception/AuthException.java
  63. 53
      src/main/java/com/biutag/supervision/flow/FlowService.java
  64. 9
      src/main/java/com/biutag/supervision/flow/action/Action.java
  65. 177
      src/main/java/com/biutag/supervision/flow/action/ApplyCompletionAction.java
  66. 95
      src/main/java/com/biutag/supervision/flow/action/ApplyExtensionAction.java
  67. 77
      src/main/java/com/biutag/supervision/flow/action/FirstApproveAction.java
  68. 81
      src/main/java/com/biutag/supervision/flow/action/FirstApproveReturnAction.java
  69. 109
      src/main/java/com/biutag/supervision/flow/action/FirstDistributeAction.java
  70. 81
      src/main/java/com/biutag/supervision/flow/action/FirstExtensionApproveAction.java
  71. 70
      src/main/java/com/biutag/supervision/flow/action/FirstExtensionReturnAction.java
  72. 91
      src/main/java/com/biutag/supervision/flow/action/SaveAction.java
  73. 103
      src/main/java/com/biutag/supervision/flow/action/SecondApproveAction.java
  74. 82
      src/main/java/com/biutag/supervision/flow/action/SecondApproveReturnAction.java
  75. 74
      src/main/java/com/biutag/supervision/flow/action/SecondDistributeAction.java
  76. 88
      src/main/java/com/biutag/supervision/flow/action/SecondExtensionApproveAction.java
  77. 70
      src/main/java/com/biutag/supervision/flow/action/SecondExtensionReturnAction.java
  78. 31
      src/main/java/com/biutag/supervision/flow/action/SecondLocalProcessingAction.java
  79. 45
      src/main/java/com/biutag/supervision/flow/action/SecondSignAction.java
  80. 81
      src/main/java/com/biutag/supervision/flow/action/SecondSignReturnAction.java
  81. 46
      src/main/java/com/biutag/supervision/flow/action/ThreeSignAction.java
  82. 96
      src/main/java/com/biutag/supervision/flow/action/ThreeSignReturnAction.java
  83. 72
      src/main/java/com/biutag/supervision/job/Job.java
  84. 10
      src/main/java/com/biutag/supervision/mapper/BaseAccountMapper.java
  85. 10
      src/main/java/com/biutag/supervision/mapper/BaseRoleMapper.java
  86. 10
      src/main/java/com/biutag/supervision/mapper/BaseRoleUserMapper.java
  87. 10
      src/main/java/com/biutag/supervision/mapper/BaseUserMapper.java
  88. 8
      src/main/java/com/biutag/supervision/mapper/DataPetitionComplaintMapper.java
  89. 8
      src/main/java/com/biutag/supervision/mapper/FlowActionMapper.java
  90. 8
      src/main/java/com/biutag/supervision/mapper/FlowNodeMapper.java
  91. 8
      src/main/java/com/biutag/supervision/mapper/HolidayMapper.java
  92. 10
      src/main/java/com/biutag/supervision/mapper/MenuMapper.java
  93. 8
      src/main/java/com/biutag/supervision/mapper/ModelClassMapper.java
  94. 8
      src/main/java/com/biutag/supervision/mapper/ModelMapper.java
  95. 8
      src/main/java/com/biutag/supervision/mapper/NegDepartAuthorityMapper.java
  96. 8
      src/main/java/com/biutag/supervision/mapper/NegSourceAuthorityMapper.java
  97. 8
      src/main/java/com/biutag/supervision/mapper/NegativeApproveMapper.java
  98. 8
      src/main/java/com/biutag/supervision/mapper/NegativeBlameMapper.java
  99. 8
      src/main/java/com/biutag/supervision/mapper/NegativeExtensionApplyMapper.java
  100. 8
      src/main/java/com/biutag/supervision/mapper/NegativeExtensionApproveMapper.java
  101. Some files were not shown because too many files have changed in this diff Show More

33
.gitignore vendored

@ -0,0 +1,33 @@
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/

19
.mvn/wrapper/maven-wrapper.properties vendored

@ -0,0 +1,19 @@
# 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.
wrapperVersion=3.3.2
distributionType=only-script
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.7/apache-maven-3.9.7-bin.zip

1978
demo.json

File diff suppressed because it is too large Load Diff

259
mvnw vendored

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

149
mvnw.cmd vendored

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

184
pom.xml

@ -0,0 +1,184 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.3.2</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.biutag</groupId>
<artifactId>supervision</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>supervision</name>
<description>长沙公安数据督察</description>
<url/>
<licenses>
<license/>
</licenses>
<developers>
<developer/>
</developers>
<scm>
<connection/>
<developerConnection/>
<tag/>
<url/>
</scm>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-spring-boot3-starter</artifactId>
<version>3.5.7</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-core</artifactId>
<version>5.8.29</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-http</artifactId>
<version>5.8.29</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot3-starter</artifactId>
<version>4.3.1</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.32</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-crypto</artifactId>
</dependency>
<dependency>
<groupId>com.github.tobato</groupId>
<artifactId>fastdfs-client</artifactId>
<version>1.27.2</version>
</dependency>
<!--knife4j-->
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
<version>4.1.0</version>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>application.yml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
<finalName>supervision</finalName>
</build>
<profiles>
<profile>
<id>dev</id>
<properties>
<!-- 环境标识,需要与配置文件的名称相对应 -->
<profiles.active>dev</profiles.active>
</properties>
<activation>
<!-- 默认环境 -->
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<profile>
<id>prod</id>
<properties>
<profiles.active>prod</profiles.active>
</properties>
</profile>
</profiles>
</project>

2
sql/0911.sql

@ -0,0 +1,2 @@
ALTER TABLE `negative`.`negative`
ADD COLUMN `case_number` varchar(255) NULL COMMENT '涉及案件/警情编号' AFTER `handle_three_depart_name`;

83
sql/data.sql

@ -0,0 +1,83 @@
CREATE TABLE data_case_verification (
origin_id varchar(255) NOT NULL COMMENT '样本源头编号(案件编号)',
discovery_time datetime NULL COMMENT '问题发现时间(受理时间)',
happen_time datetime NULL COMMENT '问题发生时间',
problem_sources varchar(255) NULL COMMENT '问题来源',
complainant varchar(255) NULL COMMENT '投诉反映人(投诉人)',
complainant_phone varchar(255) NULL COMMENT '联系电话(投诉人电话)',
business_type_name varchar(255) NULL COMMENT '业务类别',
involve_problem varchar(255) NULL COMMENT '涉嫌问题(问题类别)',
police_type varchar(255) NULL COMMENT '涉及警种',
police_type_name varchar(255) NULL COMMENT '涉及警种名称',
involve_depart_id varchar(40) NULL COMMENT '涉及单位(被投诉单位)',
thing_desc text NULL COMMENT '事情简述(投诉具体内容)',
check_status_name varchar(255) NULL COMMENT '核查情况(审定结果)',
check_status_desc varchar(255) NULL COMMENT '核查处理结果(处理情况简要描述)',
involved_name varchar(255) NULL COMMENT '涉及人姓名',
involved_id_code varchar(40) NULL COMMENT '身份证号码',
personnel_attr varchar(255) NULL COMMENT '人员属性',
inspection_measures varchar(255) NULL COMMENT '督察措施',
problem_type varchar(255) NULL COMMENT '问题类型',
problem_category varchar(255) NULL COMMENT '问题类别',
subjective_aspect varchar(255) NULL COMMENT '主观方面',
responsibility_category varchar(255) NULL COMMENT '责任类别',
processing_results varchar(255) NULL COMMENT '处理结果',
involved_rights_protection_fault_tolerance varchar(255) NULL COMMENT '维权容错',
assistance_situation varchar(255) NULL COMMENT '帮扶情况',
assistance_start_time datetime NULL COMMENT '帮扶开始时间',
assistance_end_time datetime NULL COMMENT '帮扶结束时间',
involved_leader_name varchar(255) NULL COMMENT '涉及领导姓名',
involved_leader_id_code varchar(40) NULL COMMENT '涉及领导-身份证号码',
involved_leader_inspection_measures varchar(255) NULL COMMENT '涉及领导-督察措施',
involved_leader_responsibility_category varchar(255) NULL COMMENT '涉及领导-责任类别',
involved_leader_processing_results varchar(255) NULL COMMENT '涉及领导-处理结果',
involved_leader_rights_protection_fault_tolerance varchar(255) NULL COMMENT '涉及领导-维权容错',
crt_time datetime NULL DEFAULT now(),
upd_time datetime NULL DEFAULT now(),
PRIMARY KEY (`origin_id`)
) COMMENT='案件核查台账';
CREATE TABLE data_petition_complaint (
letter_id varchar(255) COMMENT '信件编号',
channel_for_filing_complaints varchar(255) COMMENT '投诉渠道',
acceptance_level varchar(255) COMMENT '受理层级',
registration_time datetime COMMENT '登记时间',
complainant varchar(255) COMMENT '投诉人',
complainant_phone varchar(255) COMMENT '投诉人电话',
initial_petition varchar(255) COMMENT '初重信访',
entanglement_disturbance_during_visits varchar(255) COMMENT '缠访闹访',
mass_visits varchar(255) COMMENT '群众集访',
involve_problem varchar(255) COMMENT '涉嫌问题',
business_type_name varchar(255) COMMENT '业务类别',
police_type varchar(255) NULL COMMENT '涉及警种',
police_type_name varchar(255) NULL COMMENT '涉及警种名称',
complained_depart_id varchar(255) COMMENT '被投诉机构ID',
complained_depart_name varchar(255) COMMENT '被投诉机构',
thing_desc text COMMENT '具体内容',
involve_depart_id varchar(255) COMMENT '涉及单位',
involve_depart_name varchar(255) COMMENT '涉及单位',
is_unit_responsible int COMMENT '是否单位责任',
depart_processing_results varchar(255) COMMENT '单位处理结果',
involved_name varchar(255) COMMENT '涉及人姓名',
involved_id_code varchar(40) COMMENT '身份证号码',
personnel_attributes varchar(255) COMMENT '人员属性',
inspection_measures varchar(255) COMMENT '督察措施',
problem_type varchar(255) COMMENT '问题类型',
subjective_aspect varchar(255) COMMENT '主观方面',
responsibility_category varchar(255) COMMENT '责任类别',
processing_results varchar(255) COMMENT '处理结果',
rights_protection_fault_tolerance varchar(255) COMMENT '维权容错',
assistance_situation varchar(255) COMMENT '帮扶情况',
assistance_start_time datetime NULL COMMENT '帮扶开始时间',
assistance_end_time datetime NULL COMMENT '帮扶结束时间',
involved_leader_name varchar(255) COMMENT '涉及领导姓名',
involved_leader_id_code varchar(255) COMMENT '身份证号码',
involved_leader_inspection_measures varchar(255) COMMENT '督察措施',
involved_leader_responsibility_category varchar(255) COMMENT '责任类别',
involved_leader_processing_results varchar(255) COMMENT '处理结果',
involved_leader_rights_protection_fault_tolerance varchar(255) COMMENT '维权容错',
crt_time datetime NULL DEFAULT now(),
upd_time datetime NULL DEFAULT now(),
PRIMARY KEY (`letter_id`)
) COMMENT='信访投诉台账';

25
sql/dict.sql

@ -0,0 +1,25 @@
INSERT INTO `negative`.`sup_dict_type`(`dict_id`, `dict_name`, `dict_type`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (17, '主办层级', 'hostLevel', '0', '', '2024-08-13 16:21:32', '', '2024-08-13 16:21:32', '');
INSERT INTO `negative`.`sup_dict_type`(`dict_id`, `dict_name`, `dict_type`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (18, '办理时限', 'timeLimit', '0', '', '2024-08-13 16:42:50', '', '2024-08-13 16:42:50', '');
INSERT INTO `negative`.`sup_dict_type`(`dict_id`, `dict_name`, `dict_type`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (19, '审批流程', 'approvalFlow', '0', '', '2024-08-13 16:54:26', '', '2024-08-13 16:54:26', '');
INSERT INTO `negative`.`sup_dict_type`(`dict_id`, `dict_name`, `dict_type`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (20, '追责对象', 'accountabilityTarget', '0', '', '2024-08-16 10:23:19', '', '2024-08-16 10:23:19', '');
INSERT INTO `negative`.`sup_dict_type`(`dict_id`, `dict_name`, `dict_type`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (21, '办理状态', 'processingStatus', '0', '', '2024-08-19 15:37:24', '', '2024-08-19 15:37:24', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (220, 0, '市局主办', '1', 'hostLevel', '', '', '0', '0', '', '2024-08-13 16:34:23', '', '2024-08-13 16:34:23', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (222, 0, '二级机构主办', '2', 'hostLevel', '', '', '0', '0', '', '2024-08-13 16:39:09', '', '2024-08-13 16:39:09', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (223, 0, '三级机构主办', '3', 'hostLevel', '', '', '0', '0', '', '2024-08-13 16:39:44', '', '2024-08-13 16:39:44', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (224, 0, '137工作制', '3+7', 'timeLimit', '', '', '0', '0', '', '2024-08-13 16:44:13', '', '2024-08-13 16:44:13', '1个工作日签收,3个工作日办结,延期不超过7天');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (225, 0, '10+10工作制', '10+10', 'timeLimit', '', '', '0', '0', '', '2024-08-13 16:45:49', '', '2024-08-13 16:45:49', '1个工作日签收,10个工作日办结,延期不超过10天');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (226, 0, '14+7工作制', '14+7', 'timeLimit', '', '', '0', '0', '', '2024-08-13 16:46:56', '', '2024-08-13 16:46:56', '1个工作日签收,14个工作日办结,延期不超过7天');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (227, 0, '其他', 'other', 'timeLimit', '', '', '0', '0', '', '2024-08-13 16:49:33', '', '2024-08-13 16:49:33', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (228, 0, '三级审批', '3', 'approvalFlow', '', '', '0', '0', '', '2024-08-13 16:55:14', '', '2024-08-13 16:55:14', '所队一>二級机构一>市局');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (229, 0, '二级审批', '2', 'approvalFlow', '', '', '0', '0', '', '2024-08-13 16:55:29', '', '2024-08-13 16:55:29', '所队一>二级机构');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (230, 0, '涉及个人', '1', 'accountabilityTarget', '', '', '0', '0', '', '2024-08-16 10:24:48', '', '2024-08-16 10:24:48', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (231, 0, '涉及单位', '2', 'accountabilityTarget', '', '', '0', '0', '', '2024-08-16 10:25:02', '', '2024-08-16 10:25:02', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (232, 0, '涉及个人及单位', '3', 'accountabilityTarget', '', '', '0', '0', '', '2024-08-16 10:25:16', '', '2024-08-16 10:25:16', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (233, 0, '签收中', 'signing', 'processingStatus', '', '', '0', '0', '', '2024-08-19 15:38:20', '', '2024-08-19 15:38:20', '问题签收');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (234, 0, '办理中', 'processing', 'processingStatus', '', '', '0', '0', '', '2024-08-19 15:39:01', '', '2024-08-19 15:39:01', '核查办理');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (235, 0, '审批中', 'approval', 'processingStatus', '', '', '0', '0', '', '2024-08-19 15:40:34', '', '2024-08-19 15:40:34', '办结审批');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (236, 0, '已办结', 'completed', 'processingStatus', '', '', '0', '0', '', '2024-08-19 15:41:07', '', '2024-08-19 15:41:07', '认定办结');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (237, 2, '分局通报批评', '1-2', 'handleResult', '', '', '0', '0', '', '2024-09-04 18:45:08', '', '2024-09-04 18:45:08', '');
INSERT INTO `negative`.`sup_dict_data`(`dict_code`, `dict_sort`, `dict_label`, `dict_value`, `dict_type`, `css_class`, `list_class`, `is_default`, `status`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES (238, 3, '市局通报批评', '1-1', 'handleResult', '', '', '0', '0', '', '2024-09-04 18:45:47', '', '2024-09-04 18:45:47', '');

8
sql/file_class.sql

@ -0,0 +1,8 @@
CREATE TABLE file_class (
id int NOT NULL AUTO_INCREMENT,
class_name varchar(255) not null,
class_remarks varchar(255),
problem_sources_code varchar(40) not null COMMENT '问题来源',
sort int,
PRIMARY KEY (`id`)
) COMMENT='文件分类';

548
sql/negative_0904.sql

@ -0,0 +1,548 @@
ALTER TABLE `negative`.`negative`
ADD COLUMN `host_level` varchar(255) NULL COMMENT '主办层级' AFTER `distribute_flow`,
ADD COLUMN `time_limit` varchar(255) NULL COMMENT '办理时限' AFTER `host_level`,
ADD COLUMN `approval_flow` varchar(255) NULL COMMENT '审批流程' AFTER `time_limit`,
ADD COLUMN `flow_key` varchar(255) NULL COMMENT '流程节点key' AFTER `flow_key`,
ADD COLUMN `check_status_desc` text NULL COMMENT '问题核查情况' AFTER `flow_key`,
ADD COLUMN `rectify_desc` text NULL COMMENT '问题整改情况' AFTER `check_status_desc`,
ADD COLUMN `rectify_restriction_days` int NULL COMMENT '整改限制天数' AFTER `rectify_desc`,
ADD COLUMN `accountability_target` varchar(255) NULL COMMENT '追责对象' AFTER `rectify_restriction_days`,
ADD COLUMN `processing_status` varchar(255) NULL COMMENT '办理状态' AFTER `accountability_target`,
ADD COLUMN `negative_extension_apply_id` int NULL COMMENT '延期申请ID' AFTER `processing_status`,
ADD COLUMN `extension_apply_flag` tinyint NULL DEFAULT 1 COMMENT '是否能申请延期' AFTER `negative_extension_apply_id`,
ADD COLUMN `extension_days` int NULL COMMENT '延期天数' AFTER `extension_apply_flag`,
ADD COLUMN `first_distribute_time` datetime NULL COMMENT '市局下发时间' AFTER `extension_days`,
ADD COLUMN `is_second_handle` tinyint NULL DEFAULT 0 COMMENT '是否是二级机构办理 true=是 false=否' AFTER `first_distribute_time`,
ADD COLUMN `handle_second_depart_id` varchar(255) NULL COMMENT '二级办理单位' AFTER `is_second_handle`,
ADD COLUMN `handle_second_depart_name` varchar(255) NULL COMMENT '二级办理单位' AFTER `handle_second_depart_id`,
ADD COLUMN `handle_three_depart_id` varchar(255) NULL COMMENT '三级办理单位' AFTER `handle_second_depart_name`,
ADD COLUMN `handle_three_depart_name` varchar(255) NULL COMMENT '三级办理单位' AFTER `handle_three_depart_id`;
CREATE TABLE `flow_action` (
`id` int(0) NOT NULL AUTO_INCREMENT,
`action_key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
`flow_key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
`next_flow_key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '下一流程节点key',
`button_label` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '动作名称',
`button_type` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '按钮类型',
`plain` tinyint(1) NULL DEFAULT NULL COMMENT '是否是简单按钮',
`sort` int(0) NULL DEFAULT NULL COMMENT '排序',
`action_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
`validate_form` tinyint(0) NULL DEFAULT NULL COMMENT '是否需要校验表单',
`do_close` tinyint(0) NULL DEFAULT NULL COMMENT '完成后是否需要关闭',
`open_dialog` tinyint(0) NULL DEFAULT NULL COMMENT '是否需要启动对话框',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 20 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '流程节点动作' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of flow_action
-- ----------------------------
INSERT INTO `flow_action` VALUES (1, 'apply_completion', 'verify', 'second_approve', '提交审批', 'primary', 0, 4, '提交审批', 1, 1, 1);
INSERT INTO `flow_action` VALUES (2, 'apply_extension', 'verify', 'second_extension_approve', '申请延期', 'primary', 1, 3, '申请延期', 0, 0, 1);
INSERT INTO `flow_action` VALUES (3, 'first_approve', 'first_approve', 'completed', '审批通过', 'primary', 0, 2, '已审批', NULL, 1, 1);
INSERT INTO `flow_action` VALUES (4, 'first_approve_return', 'first_approve', 'second_approve', '退回整改', 'danger', 1, 1, '已退回', NULL, NULL, NULL);
INSERT INTO `flow_action` VALUES (5, 'first_distribute', 'first_distribute', 'second_sign', '下发问题', 'primary', 0, 1, '已下发', 1, 1, NULL);
INSERT INTO `flow_action` VALUES (6, 'save', 'verify', 'verify', '保存信息', 'primary', 1, 1, NULL, 1, 0, NULL);
INSERT INTO `flow_action` VALUES (7, 'second_approve', 'second_approve', 'first_approve', '审批通过', 'primary', 0, 2, '已审批', NULL, NULL, 1);
INSERT INTO `flow_action` VALUES (8, 'second_approve_return', 'second_approve', 'verify', '退回整改', 'danger', 1, 1, '退回整改', NULL, 1, 1);
INSERT INTO `flow_action` VALUES (9, 'second_distribute', 'second_distribute', 'three_sign', '下发问题', 'primary', 0, 3, '已下发', 1, 1, NULL);
INSERT INTO `flow_action` VALUES (10, 'second_sign', 'second_sign', 'second_distribute', '确认签收', 'primary', 0, 3, '已签收', 0, 0, NULL);
INSERT INTO `flow_action` VALUES (11, 'second_sign_return', 'second_sign', 'first_distribute', '问题退回', 'danger', 1, 1, '已退回', 0, 0, NULL);
INSERT INTO `flow_action` VALUES (12, 'three_sign', 'three_sign', 'verify', '确认签收', 'primary', 0, 2, '已签收', 0, 0, NULL);
INSERT INTO `flow_action` VALUES (13, 'three_sign_return', 'verify', 'second_distribute', '问题退回', 'danger', 0, 2, '已退回', NULL, 1, 1);
INSERT INTO `flow_action` VALUES (14, 'second_sign_return', 'second_distribute', 'first_distribute', '问题退回', 'danger', 1, 1, '已退回', 0, 1, 1);
INSERT INTO `flow_action` VALUES (15, 'second_extension_approve', 'second_extension_approve', 'first_extension_approve', '审批通过', 'primary', 0, 2, '延期申请已审批', 0, 1, 1);
INSERT INTO `flow_action` VALUES (16, 'second_extension_return', 'second_extension_approve', NULL, '审批驳回', 'danger', 0, 1, '延期申请已驳回', 0, 1, 1);
INSERT INTO `flow_action` VALUES (17, 'first_extension_approve', 'first_extension_approve', '', '审批通过', 'primary', 0, 2, '延期申请已审批', 0, 1, 1);
INSERT INTO `flow_action` VALUES (18, 'first_extension_return', 'first_extension_approve', NULL, '审批驳回', 'danger', 0, 1, '延期申请已驳回', 0, 1, 1);
INSERT INTO `flow_action` VALUES (19, 'second_local_processing', 'second_distribute', 'verify', '本级处理', 'primary', 1, 2, '本级处理', 0, 0, 0);
INSERT INTO `flow_action` VALUES (20, 'three_sign_return', 'three_sign', 'second_distribute', '问题退回', 'danger', 0, 1, '已退回', NULL, 1, 1);
CREATE TABLE `flow_node` (
`flow_key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
`flow_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '流程节点名称',
`flow_sort` int(0) NULL DEFAULT NULL COMMENT '排序',
PRIMARY KEY (`flow_key`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '流程节点' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of flow_node
-- ----------------------------
INSERT INTO `flow_node` VALUES ('completed', '已办结', 10);
INSERT INTO `flow_node` VALUES ('first_approve', '市局审批', 7);
INSERT INTO `flow_node` VALUES ('first_distribute', '市局下发', 1);
INSERT INTO `flow_node` VALUES ('first_extension_approve', '市局延期审批', 9);
INSERT INTO `flow_node` VALUES ('second_approve', '二级机构审批', 6);
INSERT INTO `flow_node` VALUES ('second_distribute', '二级机构下发', 3);
INSERT INTO `flow_node` VALUES ('second_extension_approve', '二级机构延期审批', 8);
INSERT INTO `flow_node` VALUES ('second_sign', '二级机构签收', 2);
INSERT INTO `flow_node` VALUES ('three_sign', '三级机构签收', 4);
INSERT INTO `flow_node` VALUES ('verify', '核查办理', 5);
CREATE TABLE holiday (
id int NOT NULL AUTO_INCREMENT,
date varchar(255) NOT NULL COMMENT '日期',
flag tinyint NOT NULL COMMENT '是否是节假日',
holiday_name varchar(255) COMMENT '节假日名称',
year int NOT NULL COMMENT '',
PRIMARY KEY (`id`)
) COMMENT='节假日';
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-01', 1, '元旦', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-02', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-03', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-04', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-06', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-07', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-10', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-13', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-14', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-16', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-17', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-20', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-21', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-27', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-28', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-01-31', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-03', 1, '劳动节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-04', 1, '劳动节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-05', 1, '劳动节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-07', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-10', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-11', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-12', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-13', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-14', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-16', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-17', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-18', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-19', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-21', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-25', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-26', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-28', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-31', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-01', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-01', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-02', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-03', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-04', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-07', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-08', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-10', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-13', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-14', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-15', 1, '中秋节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-16', 1, '中秋节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-17', 1, '中秋节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-21', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-22', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-28', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-29', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-01', 1, '国庆节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-02', 1, '国庆节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-03', 1, '国庆节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-04', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-07', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-10', 1, '初一', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-11', 1, '初二', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-12', 1, '初三', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-13', 1, '初四', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-14', 1, '初五', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-15', 1, '初六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-16', 1, '初七', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-17', 1, '初八', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-18', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-21', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-24', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-25', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-28', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-02-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-01', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-02', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-03', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-04', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-07', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-09', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-10', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-13', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-14', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-16', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-17', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-21', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-23', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-24', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-28', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-30', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-03-31', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-01', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-02', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-03', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-04', 1, '清明节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-05', 1, '清明节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-06', 1, '清明节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-07', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-10', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-13', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-14', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-16', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-17', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-20', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-21', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-27', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-28', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-04-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-01', 1, '劳动节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-05-02', 1, '劳动节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-02', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-03', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-04', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-07', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-08', 1, '端午节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-09', 1, '端午节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-10', 1, '端午节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-13', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-14', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-15', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-16', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-17', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-21', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-22', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-23', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-28', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-29', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-06-30', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-01', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-02', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-03', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-04', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-06', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-07', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-10', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-13', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-14', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-16', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-17', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-20', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-21', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-27', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-28', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-07-31', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-01', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-02', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-03', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-04', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-07', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-10', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-11', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-13', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-14', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-16', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-17', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-18', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-21', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-24', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-25', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-28', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-08-31', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-01', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-02', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-09-03', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-04', 1, '国庆节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-05', 1, '国庆节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-06', 1, '国庆节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-07', 1, '国庆节', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-10', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-12', 0, '正常上班', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-13', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-14', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-16', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-17', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-19', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-20', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-21', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-26', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-27', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-28', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-10-31', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-01', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-02', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-03', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-04', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-07', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-08', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-09', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-10', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-13', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-14', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-15', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-16', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-17', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-21', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-22', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-23', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-24', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-28', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-29', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-11-30', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-01', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-02', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-03', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-04', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-05', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-06', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-07', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-08', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-09', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-10', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-11', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-12', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-13', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-14', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-15', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-16', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-17', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-18', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-19', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-20', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-21', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-22', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-23', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-24', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-25', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-26', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-27', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-28', 1, '周六', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-29', 1, '周日', 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-30', 0, NULL, 2024);
INSERT INTO holiday (date, flag, holiday_name, year) VALUES ('2024-12-31', 0, NULL, 2024);
CREATE TABLE negative_approve (
id int NOT NULL AUTO_INCREMENT,
negative_id varchar(40) not null,
state varchar(40) not null,
handler_depart_id varchar(40),
handler_depart_name varchar(255),
handler_user_name varchar(255),
handler_name varchar(255),
comments text COMMENT '审批意见',
action_key varchar(255),
create_time datetime DEFAULT now(),
PRIMARY KEY (`id`)
) COMMENT='问题审批';
CREATE TABLE negative_extension_apply (
id int NOT NULL AUTO_INCREMENT,
negative_id varchar(40) not null,
handler_depart_id varchar(40),
handler_depart_name varchar(255),
handler_user_name varchar(255),
handler_name varchar(255),
comments text COMMENT '延期理由',
extension_days int COMMENT '延期天数',
create_time datetime DEFAULT now(),
PRIMARY KEY (`id`)
) COMMENT='问题申请延期';
CREATE TABLE negative_extension_approve (
id int NOT NULL AUTO_INCREMENT,
negative_id varchar(40) not null,
negative_extension_apply_id int not null,
handler_depart_id varchar(40),
handler_depart_name varchar(255),
handler_user_name varchar(255),
handler_name varchar(255),
comments text COMMENT '审批意见/驳回理由',
state varchar(40) not null,
action_key varchar(255),
create_time datetime DEFAULT now(),
PRIMARY KEY (`id`)
) COMMENT='问题申请延期';
CREATE TABLE negative_fav (
id int NOT NULL AUTO_INCREMENT,
negative_id varchar(40) not null,
user_id varchar(40) not null,
create_time datetime DEFAULT now(),
PRIMARY KEY (`id`)
) COMMENT='问题收藏';
CREATE TABLE negative_sign_return (
id int NOT NULL AUTO_INCREMENT,
negative_id varchar(40) not null,
handler_depart_id varchar(40),
handler_depart_name varchar(255),
handler_user_name varchar(255),
handler_name varchar(255),
comments text COMMENT '退回原因',
action_key varchar(255),
create_time datetime DEFAULT now(),
PRIMARY KEY (`id`)
) COMMENT='问题签收退回';
CREATE TABLE negative_thing_file (
id int NOT NULL AUTO_INCREMENT,
negative_id varchar(40) not null,
file_name varchar(255) not null COMMENT '文件名称',
file_path varchar(255) not null COMMENT '文件路径',
type varchar(255),
create_time datetime DEFAULT now(),
PRIMARY KEY (`id`)
) COMMENT='问题事件附件';
CREATE TABLE negative_work (
id int NOT NULL AUTO_INCREMENT,
negative_id varchar(40),
depart_id varchar(40),
role_code varchar(255),
problem_sources_code varchar(255),
flow_key varchar(255),
status varchar(255) default 'todo',
create_time datetime DEFAULT now(),
update_time datetime DEFAULT now(),
PRIMARY KEY (`id`)
) COMMENT='问题工作记录表';
ALTER TABLE `negative`.`negative_file`
ADD COLUMN `file_class_id` int NULL AFTER `status`;

8
sql/negative_mark.sql

@ -0,0 +1,8 @@
CREATE TABLE negative_mark (
negative_id varchar(40),
involve_second_depart_id varchar(40) COMMENT '涉及二级单位',
involve_second_depart_name varchar(255) COMMENT '涉及二级单位名称',
involve_three_depart_id varchar(40) COMMENT '涉及三级单位',
involve_three_depart_name varchar(255) COMMENT '涉及三级单位名称',
PRIMARY KEY (`negative_id`)
) COMMENT='问题统计表';

89
sql/open-platform_0904.sql

@ -0,0 +1,89 @@
-- ----------------------------
-- Table structure for menu
-- ----------------------------
CREATE TABLE `menu` (
`id` int(0) NOT NULL AUTO_INCREMENT,
`pid` int(0) NULL DEFAULT NULL,
`menu_type` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '菜单类型',
`menu_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '菜单名称',
`icon` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '菜单图标',
`menu_sort` int(0) NULL DEFAULT NULL COMMENT '排序',
`perms` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`paths` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '路径',
`component` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '组件',
`is_cache` int(0) NOT NULL DEFAULT 0 COMMENT '是否缓存',
`is_show` int(0) NOT NULL DEFAULT 1,
`is_disable` int(0) NOT NULL DEFAULT 0,
`create_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP(0),
`update_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP(0),
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 19 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '菜单' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of menu
-- ----------------------------
INSERT INTO `menu` VALUES (1, 0, 'C', '首页', 'el-icon-House', 1, NULL, '/', 'Home', 1, 1, 0, '2024-08-06 17:13:17', '2024-08-07 15:49:38');
INSERT INTO `menu` VALUES (2, 0, 'C', '一体化大屏', 'el-icon-PieChart', 1, NULL, '/bigscreen', NULL, 1, 1, 0, '2024-08-06 17:20:08', '2024-08-07 15:50:25');
INSERT INTO `menu` VALUES (3, 0, 'M', '我的工作', 'el-icon-Box', 1, NULL, '/work', NULL, 1, 1, 0, '2024-08-06 17:20:42', '2024-08-07 15:51:05');
INSERT INTO `menu` VALUES (4, 0, 'M', '系统管理', 'el-icon-Setting', NULL, NULL, '/system', NULL, 1, 1, 0, '2024-08-06 17:23:12', '2024-08-26 15:47:58');
INSERT INTO `menu` VALUES (5, 3, 'C', '我的待办', NULL, 10, NULL, '/work/todo', '/work/Todo', 1, 1, 0, '2024-08-06 17:26:38', '2024-08-07 16:55:48');
INSERT INTO `menu` VALUES (6, 3, 'C', '我的已办', NULL, 9, NULL, '/work/done', '/work/Done', 1, 1, 0, '2024-08-06 17:26:59', '2024-08-07 16:56:10');
INSERT INTO `menu` VALUES (7, 4, 'C', '用户管理', NULL, 10, NULL, '/system/user', '/system/User', 1, 1, 0, '2024-08-06 17:28:19', '2024-08-09 14:19:48');
INSERT INTO `menu` VALUES (8, 4, 'C', '警员中心', NULL, 9, NULL, '/system/police', '/system/Police', 1, 1, 0, '2024-08-06 17:28:26', '2024-08-07 15:47:53');
INSERT INTO `menu` VALUES (9, 4, 'C', '菜单管理', NULL, 8, NULL, '/system/menu', '/system/Menu', 1, 1, 0, '2024-08-06 17:28:40', '2024-08-07 15:48:30');
INSERT INTO `menu` VALUES (10, 4, 'C', '角色管理', NULL, 7, NULL, '/system/role', '/system/Role', 1, 1, 0, '2024-08-07 16:54:20', '2024-08-07 16:54:20');
INSERT INTO `menu` VALUES (11, 4, 'C', '部门管理', NULL, 6, NULL, '/system/depart', '/system/Depart', 1, 1, 0, '2024-08-08 16:44:16', '2024-08-08 16:44:16');
INSERT INTO `menu` VALUES (12, 4, 'C', '数据字典', NULL, 5, NULL, '/system/dict', '/system/Dict', 1, 1, 0, '2024-08-08 16:44:59', '2024-08-08 16:44:59');
INSERT INTO `menu` VALUES (13, 4, 'C', '问题类型', NULL, NULL, NULL, '/system/dictContent', '/system/DictContent', 1, 1, 0, '2024-08-16 14:40:53', '2024-08-16 14:40:53');
INSERT INTO `menu` VALUES (14, 3, 'C', '我的收藏', NULL, NULL, NULL, '/work/myFav', '/work/Fav', 1, 1, 0, '2024-08-16 18:52:26', '2024-08-16 18:52:26');
INSERT INTO `menu` VALUES (15, 3, 'C', '综合查询', NULL, NULL, NULL, '/query', '/work/Query', 1, 1, 0, '2024-08-27 10:09:25', '2024-08-27 10:09:25');
INSERT INTO `menu` VALUES (16, 8, 'A', '新增警员', NULL, NULL, 'police:add', '', NULL, 0, 1, 0, '2024-09-03 18:38:46', '2024-09-03 18:38:46');
INSERT INTO `menu` VALUES (17, 8, 'A', '权限设置', NULL, NULL, 'police:auth', NULL, NULL, 0, 1, 0, '2024-09-03 18:45:04', '2024-09-03 18:45:04');
INSERT INTO `menu` VALUES (18, 5, 'A', '问题录入', NULL, NULL, 'negative:add', NULL, NULL, 0, 1, 0, '2024-09-04 11:29:54', '2024-09-04 11:29:54');
-- ----------------------------
-- Table structure for role_menu
-- ----------------------------
CREATE TABLE `role_menu` (
`id` int(0) NOT NULL AUTO_INCREMENT,
`role_code` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`menu_id` int(0) NULL DEFAULT NULL,
`create_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP(0) ON UPDATE CURRENT_TIMESTAMP(0),
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 103 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '角色菜单权限表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of role_menu
-- ----------------------------
INSERT INTO `role_menu` VALUES (43, 'admin_1_1_1_2', 1, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (44, 'admin_1_1_1_2', 3, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (45, 'admin_1_1_1_2', 5, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (46, 'admin_1_1_1_2', 6, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (47, 'admin_1_1_1_2', 14, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (48, 'admin_1_1_1_2', 15, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (49, 'admin_1_1_1_2', 4, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (50, 'admin_1_1_1_2', 8, '2024-09-03 18:42:22');
INSERT INTO `role_menu` VALUES (70, 'admin_1_1_1_3', 3, '2024-09-03 20:48:31');
INSERT INTO `role_menu` VALUES (71, 'admin_1_1_1_3', 5, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (72, 'admin_1_1_1_3', 6, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (73, 'admin_1_1_1_3', 14, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (74, 'admin_1_1_1_3', 15, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (75, 'admin_1_1_1_3', 1, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (76, 'admin_1_1_1_3', 4, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (77, 'admin_1_1_1_3', 8, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (78, 'admin_1_1_1_3', 16, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (79, 'admin_1_1_1_3', 17, '2024-09-03 20:48:32');
INSERT INTO `role_menu` VALUES (91, 'admin_1', 3, '2024-09-04 11:30:26');
INSERT INTO `role_menu` VALUES (92, 'admin_1', 5, '2024-09-04 11:30:26');
INSERT INTO `role_menu` VALUES (93, 'admin_1', 18, '2024-09-04 11:30:26');
INSERT INTO `role_menu` VALUES (94, 'admin_1', 6, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (95, 'admin_1', 14, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (96, 'admin_1', 15, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (97, 'admin_1', 1, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (98, 'admin_1', 4, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (99, 'admin_1', 7, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (100, 'admin_1', 8, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (101, 'admin_1', 16, '2024-09-04 11:30:27');
INSERT INTO `role_menu` VALUES (102, 'admin_1', 11, '2024-09-04 11:30:27');

4
sql/truncate.sql

@ -0,0 +1,4 @@
truncate negative_work;
truncate negative_history;
truncate negative_fav;
truncate negative_fav;

1
sql/update-data.sql

@ -0,0 +1 @@
UPDATE `negative`.`negative` set flow_key = 'completed', processing_status = 'completed';

15
src/main/java/com/biutag/supervision/SupervisionApplication.java

@ -0,0 +1,15 @@
package com.biutag.supervision;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
@EnableScheduling
@SpringBootApplication
public class SupervisionApplication {
public static void main(String[] args) {
SpringApplication.run(SupervisionApplication.class, args);
}
}

34
src/main/java/com/biutag/supervision/common/UserContextHolder.java

@ -0,0 +1,34 @@
package com.biutag.supervision.common;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.Header;
import com.biutag.supervision.constants.RedisKeyConstants;
import com.biutag.supervision.exception.AuthException;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.util.SpringUtil;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
public class UserContextHolder {
public static String getCurrentToken() {
HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
return request.getHeader(Header.AUTHORIZATION.getValue());
}
public static UserAuth getCurrentUser() {
String authorization = getCurrentToken();
if (StrUtil.isBlank(authorization)) {
throw new AuthException();
}
UserAuth userAuth = (UserAuth) SpringUtil.getBean("redisTemplate", RedisTemplate.class).opsForValue().get(String.format(RedisKeyConstants.LOGIN_USERINFO_KEY, authorization));
return userAuth;
}
public static String getCurrentUserId() {
return getCurrentUser().getUserId();
}
}

20
src/main/java/com/biutag/supervision/config/FastDFSConfig.java

@ -0,0 +1,20 @@
package com.biutag.supervision.config;
import com.github.tobato.fastdfs.domain.conn.TrackerConnectionManager;
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("com.github.tobato.fastdfs")
@Configuration
public class FastDFSConfig {
@Autowired
private TrackerConnectionManager trackerConnectionManager;
@PostConstruct
public void init() {
trackerConnectionManager.initTracker();
}
}

62
src/main/java/com/biutag/supervision/config/GlobalExceptionHandler.java

@ -0,0 +1,62 @@
package com.biutag.supervision.config;
import com.biutag.supervision.exception.AuthException;
import com.biutag.supervision.pojo.Result;
import jakarta.validation.ValidationException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataAccessException;
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 java.util.stream.Collectors;
@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {
@ResponseStatus(HttpStatus.OK)
@ExceptionHandler(Exception.class)
@ResponseBody
public Result<Object> handleException(Exception e) {
log.error("系统异常: {}", e.getMessage(), e);
return Result.failed(e.getMessage());
}
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ExceptionHandler(DataAccessException.class)
@ResponseBody
public Result<Object> handleDataAccessException(DataAccessException e) {
log.error("数据库异常: {}", e.getMessage(), e);
return Result.failed(String.format("数据库异常:%s", e.getMessage()));
}
@ResponseStatus(HttpStatus.UNAUTHORIZED)
@ExceptionHandler(AuthException.class)
@ResponseBody
public Result<Object> handleAuthException(AuthException e) {
log.error("未授权", e);
return Result.failed(HttpStatus.UNAUTHORIZED.value(), HttpStatus.UNAUTHORIZED.getReasonPhrase());
}
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseBody
public Result<Object> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
String message = e.getBindingResult().getFieldErrors().stream().map(item -> item.getField() + " : " + item.getDefaultMessage()).collect(Collectors.joining("; "));
log.error("参数错误: {}", message, e);
return Result.failed(HttpStatus.BAD_REQUEST.value(), String.format("参数错误:%s", message));
}
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(ValidationException.class)
@ResponseBody
public Result<Object> handleValidationException(ValidationException e) {
log.error("参数错误", e);
return Result.failed(HttpStatus.BAD_REQUEST.value(), e.getMessage());
}
}

68
src/main/java/com/biutag/supervision/config/InterceptorConfig.java

@ -0,0 +1,68 @@
package com.biutag.supervision.config;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.Header;
import com.biutag.supervision.constants.RedisKeyConstants;
import com.biutag.supervision.exception.AuthException;
import com.biutag.supervision.util.SpringUtil;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.List;
import java.util.Objects;
/**
* @author wxc
* @date 2024/1/8
*/
@Slf4j
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new DefaultInterceptor())
.addPathPatterns("/**")
.excludePathPatterns("/api/**")
.excludePathPatterns("/login")
.excludePathPatterns("/auth/self")
.excludePathPatterns("/file/stream/**", "/templates/**")
.excludePathPatterns(List.of("/doc.html", "/webjars/**", "/favicon.ico", "/v3/api-docs/**"));
registry.addInterceptor(new ApiInterceptor())
.addPathPatterns("/api/jwdc/**");
}
static class DefaultInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
log.info("请求地址:{}", request.getRequestURI());
String authorization = request.getHeader(Header.AUTHORIZATION.getValue());
RedisTemplate<Object, Object> redisTemplate = SpringUtil.getBean("redisTemplate", RedisTemplate.class);
if (StrUtil.isBlank(authorization) || Objects.isNull(redisTemplate.opsForValue().get(String.format(RedisKeyConstants.LOGIN_USERINFO_KEY, authorization)))) {
throw new AuthException();
}
return true;
}
}
static class ApiInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
log.info("请求地址【API】:{}", request.getRequestURI());
String authorization = request.getHeader("Authorization");
if (!"565318a8ea367e03904e1c241048dd6c".equals(authorization)) {
throw new AuthException();
}
return true;
}
}
}

22
src/main/java/com/biutag/supervision/config/MybatisPlusConfig.java

@ -0,0 +1,22 @@
package com.biutag.supervision.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@MapperScan("com.biutag.supervision.mapper")
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 如果配置多个插件, 切记分页最后添加
// 如果有多数据源可以不配具体类型, 否则都建议配上具体的 DbType
return interceptor;
}
}

28
src/main/java/com/biutag/supervision/config/SwaggerConfig.java

@ -0,0 +1,28 @@
package com.biutag.supervision.config;
import io.swagger.v3.oas.models.ExternalDocumentation;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springdoc.core.models.GroupedOpenApi;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
@Configuration
public class SwaggerConfig {
@Bean
public OpenAPI springShopOpenAPI() {
return new OpenAPI()
.info(new Info().title("长沙公安数字督察一体化平台接口文档")
.contact(new Contact())
.description("长沙公安数字督察一体化平台接口文档")
.version("v1")
.license(new License().name("长沙市公安局").url("")))
.externalDocs(new ExternalDocumentation()
.description("接口文档"));
}
}

26
src/main/java/com/biutag/supervision/constants/AppConstants.java

@ -0,0 +1,26 @@
package com.biutag.supervision.constants;
public class AppConstants {
public static final int MENU_ROOT_ID = 0;
// 部门
public static final String DICT_CONTENT_ROOT_PARENT_CODE = "-1";
// 管理员类型类型(超级管理员)
public static final String USER_TYPE_SUPER = "super";
// 部门
public static final String DEPART_ROOT_PID = "0";
// 部门跟节点ID(长沙市公安局)
public static final String ROOT_DEPART_ID = "12630";
public static final String ROOT_DEPART_NAME = "长沙市公安局";
//
public static final String SIGN_RETURN_ACTION_NAME = "已退回";
}

6
src/main/java/com/biutag/supervision/constants/RedisKeyConstants.java

@ -0,0 +1,6 @@
package com.biutag.supervision.constants;
public class RedisKeyConstants {
public final static String LOGIN_USERINFO_KEY = "login:userinfo:%s";
}

17
src/main/java/com/biutag/supervision/constants/enums/ApprovalFlowEnum.java

@ -0,0 +1,17 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum ApprovalFlowEnum {
// 二级审批 所队一>二级机构
SECOND_APPROVAL("2"),
// 三级审批 所队一>二級机构一>市局
THREE_APPROVAL("3");
private String value;
}

7
src/main/java/com/biutag/supervision/constants/enums/ApproveStateEnum.java

@ -0,0 +1,7 @@
package com.biutag.supervision.constants.enums;
public enum ApproveStateEnum {
approved,
rejected;
}

35
src/main/java/com/biutag/supervision/constants/enums/BusinessTypeEnum.java

@ -0,0 +1,35 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@AllArgsConstructor
@Getter
public enum BusinessTypeEnum {
JCJ_110("110接处警", "1", "110"),
JCJ_122("122接处警", "2", "122"),
RJCKFW("人境窗口服务", "3", "RJ"),
CJGFF("车驾管服务", "4", "CJG"),
JJCF("交警执法", "5", "JJ"),
ZFBA("执法办案", "6", "CF"),
ZXGZ("专项工作", "7", "ZX"),
ABWW("安保维稳", "8", "AB"),
JAFK("治安防控", "9", "ZA"),
XZGL("行政管理", "10", "XZ");
private String label;
private String value;
private String key;
public static BusinessTypeEnum get(String value) {
for (BusinessTypeEnum businessTypeEnum : values()) {
if (businessTypeEnum.value.equals(value)) {
return businessTypeEnum;
}
}
throw new RuntimeException("无此业务类型");
}
}

16
src/main/java/com/biutag/supervision/constants/enums/DepartLevelEnum.java

@ -0,0 +1,16 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@AllArgsConstructor
@Getter
public enum DepartLevelEnum {
SECOND_CATEGORY(1),
SECOND(2),
THREE(3);
private int value;
}

19
src/main/java/com/biutag/supervision/constants/enums/FlowActionEnum.java

@ -0,0 +1,19 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@AllArgsConstructor
public enum FlowActionEnum {
FIRST_DISTRIBUTE("first_distribute", "已下发"),
SECOND_APPROVE("second_approve", "已审批"),
FIRST_APPROVE("first_approve", "已审批");
@Getter
private String key;
@Getter
private String name;
}

41
src/main/java/com/biutag/supervision/constants/enums/FlowNodeEnum.java

@ -0,0 +1,41 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.List;
@AllArgsConstructor
@Getter
public enum FlowNodeEnum {
FIRST_DISTRIBUTE("first_distribute"),
SECOND_SIGN("second_sign"),
SECOND_DISTRIBUTE("second_distribute"),
THREE_SIGN("three_sign"),
VERIFY("verify"),
SECOND_APPROVE("first_approve"),
FIRST_APPROVE("first_approve"),
SECOND_EXTENSION_APPROVE("first_approve"),
FIRST_EXTENSION_APPROVE("first_approve"),
COMPLETED("completed");
private String key;
public static List<String> getSignFlowKeys() {
return List.of(FIRST_DISTRIBUTE.getKey(), SECOND_SIGN.getKey(), SECOND_DISTRIBUTE.getKey(), THREE_SIGN.getKey());
}
public static boolean isSignFlow(String flowKey) {
return getSignFlowKeys().contains(flowKey);
}
/**
* 办结审批
* @return
*/
public static List<String> getApproveFlowKeys() {
return List.of(FIRST_DISTRIBUTE.getKey(), SECOND_SIGN.getKey(), SECOND_DISTRIBUTE.getKey(), THREE_SIGN.getKey());
}
}

15
src/main/java/com/biutag/supervision/constants/enums/HostLevelEnums.java

@ -0,0 +1,15 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum HostLevelEnums {
FIRST("1"),
SECOND("2"),
THREE("3");
private String value;
}

28
src/main/java/com/biutag/supervision/constants/enums/InspectCaseEnum.java

@ -0,0 +1,28 @@
package com.biutag.supervision.constants.enums;
import cn.hutool.core.util.StrUtil;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum InspectCaseEnum {
// 属实
TRUE("1"),
// 部分属实
PARTIALLY_TRUE("2"),
// 不属实
FALSE("3"),
NOT_VERIFIED("4"),
OTHER("5");
private String value;
public static boolean isItTure(String value) {
return StrUtil.isNotBlank(value) && !OTHER.getValue().equals(value);
}
}

16
src/main/java/com/biutag/supervision/constants/enums/IsRectifyEnum.java

@ -0,0 +1,16 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
// 是否整改
@AllArgsConstructor
@Getter
public enum IsRectifyEnum {
NOT("0"),
YES("1");
private String value;
}

17
src/main/java/com/biutag/supervision/constants/enums/MenuEnum.java

@ -0,0 +1,17 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
@AllArgsConstructor
public enum MenuEnum {
CATALOGUE("M"),
MENU("C"),
BUTTON("A");
private String value;
public String value() {
return value;
}
}

33
src/main/java/com/biutag/supervision/constants/enums/ProblemSourcesEnum.java

@ -0,0 +1,33 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum ProblemSourcesEnum {
XFTS("信访投诉", "1"),
JWDC("警务调查", "2"),
JYDC("警意调查", "3"),
CFJD("持法监督", "4"),
WSPC("360度网上测评", "5"),
DDKQ("钉钉考勤", "6"),
JDGL("监督管理", "7"),
JCKH("检查考核", "8"),
OTHER("其他", "9"),
WJWG("违纪违规", "10");
private String label;
private String value;
public static ProblemSourcesEnum get(String value) {
for (ProblemSourcesEnum problemSourcesEnum : values()) {
if (problemSourcesEnum.value.equals(value)) {
return problemSourcesEnum;
}
}
throw new RuntimeException("无此问题来源");
}
}

11
src/main/java/com/biutag/supervision/constants/enums/ProcessingStatusEnum.java

@ -0,0 +1,11 @@
package com.biutag.supervision.constants.enums;
public enum ProcessingStatusEnum {
signing,
processing,
approval,
completed;
}

17
src/main/java/com/biutag/supervision/constants/enums/RoleCodeEnum.java

@ -0,0 +1,17 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@AllArgsConstructor
@Getter
public enum RoleCodeEnum {
ADMIN("admin"),
FIRST_ADMIN("admin_1"),
SECOND_ADMIN("admin_1_1_1_2"),
THREE_ADMIN("admin_1_1_1_3");
private String code;
}

15
src/main/java/com/biutag/supervision/constants/enums/StatusEnum.java

@ -0,0 +1,15 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum StatusEnum {
ENABLE("1"),
DISABLE("0");
private String value;
}

38
src/main/java/com/biutag/supervision/constants/enums/TimeLimitEnum.java

@ -0,0 +1,38 @@
package com.biutag.supervision.constants.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
// 办理时限
@Getter
@AllArgsConstructor
public enum TimeLimitEnum {
WORK_137("137工作制", "3+7", 1, 3, 7),
WORK_10_10("10+10工作制", "10+10", 1, 10, 10),
WORK_14_7("14+7工作制", "14+7", 1, 14, 7),
OTHER("其他", "other", null, null, null);
private String label;
private String value;
// 签收时长(天)
private Integer maxSignDuration;
// 办理时长(天)
private Integer maxHandleDuration;
// 最大延期时长(天)
private Integer maxExtensionDuration;
public static TimeLimitEnum get(String value) {
for (TimeLimitEnum timeLimitEnum : values()) {
if (timeLimitEnum.getValue().equals(value)) {
return timeLimitEnum;
}
}
throw new RuntimeException(String.format("办理时限字典[%s]未找到", value));
}
}

7
src/main/java/com/biutag/supervision/constants/enums/WorkStateEnum.java

@ -0,0 +1,7 @@
package com.biutag.supervision.constants.enums;
public enum WorkStateEnum {
todo,
done;
}

7
src/main/java/com/biutag/supervision/constants/enums/WorkStatusEnum.java

@ -0,0 +1,7 @@
package com.biutag.supervision.constants.enums;
public enum WorkStatusEnum {
todo,
done;
}

76
src/main/java/com/biutag/supervision/controller/AuthController.java

@ -0,0 +1,76 @@
package com.biutag.supervision.controller;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.AppConstants;
import com.biutag.supervision.constants.RedisKeyConstants;
import com.biutag.supervision.exception.AuthException;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.domain.Self;
import com.biutag.supervision.pojo.entity.Menu;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.pojo.vo.MenuTree;
import com.biutag.supervision.service.MenuService;
import com.biutag.supervision.service.UserLoginService;
import com.biutag.supervision.util.JSON;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
@Slf4j
@RequiredArgsConstructor
@RequestMapping("auth")
@RestController
public class AuthController {
private final MenuService menuService;
private final UserLoginService userLoginService;
private final RedisTemplate<Object, Object> redisTemplate;
@Value("${spring.profiles.active}")
private String profilesActive;
@Value("${negative.v1-user-url:''}")
private String v1UserUrl;
@GetMapping("self")
public Result<Self> self() {
String authorization = UserContextHolder.getCurrentToken();
if (StrUtil.isBlank(authorization)) {
throw new AuthException();
}
UserAuth user = UserContextHolder.getCurrentUser();
if ("prod".equals(profilesActive)) {
if (Objects.isNull(user)) {
HttpResponse httpResponse = HttpUtil
.createGet(v1UserUrl)
.bearerAuth(authorization)
.execute();
log.info("获取用户信息:{}", httpResponse.body());
JsonNode jsonNode = JSON.readTree(httpResponse.body());
String account = jsonNode.get("data")
.get("username").asText();
user = userLoginService.buildUserAuth(account);
redisTemplate.opsForValue().set(String.format(RedisKeyConstants.LOGIN_USERINFO_KEY, authorization), user, 24, TimeUnit.HOURS);
}
}
boolean superFlag = AppConstants.USER_TYPE_SUPER.equals(user.getUserType());
List<Menu> menus = superFlag ? menuService.listAll() : menuService.listMenuByCurrentUser();
List<String> perms = superFlag ? List.of("*") : menuService.listPermsByCurrentUser();
return Result.success(new Self().setUser(user).setMenus(MenuTree.buildTree(menus)).setPerms(perms));
}
}

56
src/main/java/com/biutag/supervision/controller/FileController.java

@ -0,0 +1,56 @@
package com.biutag.supervision.controller;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.vo.FileVo;
import com.github.tobato.fastdfs.domain.fdfs.StorePath;
import com.github.tobato.fastdfs.service.FastFileStorageClient;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
@Slf4j
@RequiredArgsConstructor
@RequestMapping("file")
@Controller
public class FileController {
private final FastFileStorageClient fastFileStorageClient;
@Value("${fdfs.preview-url}")
private String FDFS_PREVIEW_URL;
@ResponseBody
@PostMapping("upload")
public Result<FileVo> upload(@RequestPart("file") MultipartFile file) throws IOException {
log.info("文件上传 upload------------------------------");
StorePath storePath = fastFileStorageClient.uploadFile("group1", file.getInputStream(), file.getSize(), FileUtil.extName(file.getOriginalFilename()));
return Result.success(new FileVo()
.setFileName(file.getOriginalFilename())
.setFilePath("/" + storePath.getFullPath()));
}
@GetMapping("stream/**")
public void download(HttpServletRequest request, HttpServletResponse response) throws IOException {
String filePath = request.getRequestURI().substring(12);
HttpResponse httpResponse = HttpUtil.createGet(FDFS_PREVIEW_URL + filePath)
.execute();
if (filePath.toLowerCase().endsWith(".pdf")) {
response.setContentType("application/pdf");
} else {
response.setContentType("application/octet-stream");
}
IoUtil.copy(httpResponse.bodyStream(), response.getOutputStream());
}
}

64
src/main/java/com/biutag/supervision/controller/LoginController.java

@ -0,0 +1,64 @@
package com.biutag.supervision.controller;
import cn.hutool.core.util.IdUtil;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.RedisKeyConstants;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.dto.AccountDto;
import com.biutag.supervision.pojo.entity.*;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.pojo.vo.TokenVo;
import com.biutag.supervision.service.*;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.crypto.bcrypt.BCrypt;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@Tag(name = "登录接口")
@Slf4j
@RequiredArgsConstructor
@RestController
public class LoginController {
private final BaseAccountService accountService;
private final UserLoginService userLoginService;
private final RedisTemplate<Object, Object> redisTemplate;
@Operation(summary = "登录")
@PostMapping("login")
public Result<TokenVo> login(@RequestBody AccountDto account) {
BaseAccount baseAccount = accountService.getByAccount(account.getAccount());
try {
if (Objects.isNull(baseAccount) || !BCrypt.checkpw(account.getPassword(), baseAccount.getPassword())) {
throw new RuntimeException("用户名或密码有误,请重新输入");
}
} catch (RuntimeException e) {
log.error(e.getMessage(), e);
throw new RuntimeException("用户名或密码有误,请重新输入");
}
UserAuth userAuth = userLoginService.buildUserAuth(baseAccount.getAccount());
String token = IdUtil.fastSimpleUUID();
redisTemplate.opsForValue().set(String.format(RedisKeyConstants.LOGIN_USERINFO_KEY, token), userAuth, 24, TimeUnit.HOURS);
return Result.success(new TokenVo().setToken(token));
}
@PostMapping("logout")
public Result<Void> logout() {
redisTemplate.opsForValue();
redisTemplate.delete(String.format(RedisKeyConstants.LOGIN_USERINFO_KEY, UserContextHolder.getCurrentToken()));
return Result.success();
}
}

157
src/main/java/com/biutag/supervision/controller/StatisticsController.java

@ -0,0 +1,157 @@
package com.biutag.supervision.controller;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.AppConstants;
import com.biutag.supervision.constants.enums.FlowNodeEnum;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.constants.enums.RoleCodeEnum;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeService;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;
@RequiredArgsConstructor
@RequestMapping("statistics")
@RestController
public class StatisticsController {
private final NegativeService negativeService;
@GetMapping("flowNumberAndTodayNumber")
public Result<Map<String, Object>> flowNumber() {
UserAuth user = UserContextHolder.getCurrentUser();
boolean authEmpty = (user.getAuthSources().isEmpty() || user.getAuthDepartIds().isEmpty()) && !AppConstants.USER_TYPE_SUPER.equals(user.getUserType());
if (authEmpty) {
Map<String, Object> data = new HashMap<>();
data.put("flowNumber", List.of(new FlowNumber("问题待签收", "sign", 0L),
new FlowNumber("核查办理", "verify", 0L),
new FlowNumber("申请延期", "delay", 0L),
new FlowNumber("办结审批", "completedApprove", 0L))
);
data.put("todayNumber", List.of(new TodayNumber("今日办结", 0L),
new TodayNumber("今日办结", 0L),
new TodayNumber("累计问题", 0L),
new TodayNumber("累计办结", 0L))
);
return Result.success(data);
}
boolean nonAdminAuth = !AppConstants.USER_TYPE_SUPER.equals(user.getUserType()) && !user.getRoleCodes().contains(RoleCodeEnum.FIRST_ADMIN.getCode());
long signCount = negativeService.count(new LambdaUpdateWrapper<Negative>()
.in(Negative::getFlowKey, FlowNodeEnum.getSignFlowKeys())
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
long verifyCount = negativeService.count(new LambdaUpdateWrapper<Negative>()
.eq(Negative::getFlowKey, FlowNodeEnum.VERIFY.getKey())
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
long delayCount = negativeService.count(new LambdaUpdateWrapper<Negative>()
.eq(Negative::getExtensionApplyFlag, false)
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
long completedApproveCount = negativeService.count(new LambdaUpdateWrapper<Negative>()
.eq(Negative::getProcessingStatus, ProcessingStatusEnum.approval.name())
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
Date now = new Date();
DateTime beginOfDay = DateUtil.beginOfDay(now);
DateTime endOfDay = DateUtil.endOfDay(now);
long todayNumber = negativeService.count(new LambdaUpdateWrapper<Negative>()
.between(Negative::getCrtTime, beginOfDay, endOfDay)
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
long todayCompleted = negativeService.count(new LambdaUpdateWrapper<Negative>()
.between(Negative::getCompleteDate, beginOfDay, endOfDay)
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
long totalNumber = negativeService.count(new LambdaUpdateWrapper<Negative>()
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
long totalCompleted = negativeService.count(new LambdaUpdateWrapper<Negative>()
.eq(Negative::getProcessingStatus, ProcessingStatusEnum.completed.name())
.in(!user.getAuthSources().isEmpty(), Negative::getProblemSourcesCode, user.getAuthSources())
.and(nonAdminAuth, query -> {
query.in(Negative::getHandleSecondDepartId, user.getAuthDepartIds()).or()
.in(Negative::getThingDesc, user.getAuthDepartIds());
})
);
Map<String, Object> data = new HashMap<>();
data.put("flowNumber", List.of(new FlowNumber("问题待签收", "sign", signCount),
new FlowNumber("核查办理", "verify", verifyCount),
new FlowNumber("申请延期", "delay", delayCount),
new FlowNumber("办结审批", "completedApprove", completedApproveCount))
);
data.put("todayNumber", List.of(new TodayNumber("今日办结", todayNumber),
new TodayNumber("今日办结", todayCompleted),
new TodayNumber("累计问题", totalNumber),
new TodayNumber("累计办结", totalCompleted))
);
return Result.success(data);
}
@Setter
@Getter
public class FlowNumber {
private String name;
private String icon;
private Long total;
public FlowNumber(String name, String icon, Long total) {
this.name = name;
this.icon = icon;
this.total = total;
}
}
@Setter
@Getter
public class TodayNumber {
private String name;
private Long total;
public TodayNumber(String name, Long total) {
this.name = name;
this.total = total;
}
}
}

49
src/main/java/com/biutag/supervision/controller/api/jwdc/NegativeApiController.java

@ -0,0 +1,49 @@
package com.biutag.supervision.controller.api.jwdc;
import com.biutag.supervision.pojo.domain.Blame;
import com.biutag.supervision.pojo.dto.jwdc.NegativeApiDto;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.service.NegativeBlameService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.util.JSON;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@Slf4j
@Validated
@RequiredArgsConstructor
@RequestMapping("api/jwdc/negative")
@RestController
public class NegativeApiController {
private final NegativeService negativeService;
private final NegativeBlameService negativeBlameService;
@PostMapping
public String addAll(@RequestBody @Valid List<NegativeApiDto> list) {
log.info("问题数据导入: {}", JSON.toJSONString(list));
negativeService.saveByJwdc(list);
return "success";
}
@GetMapping("responsible")
public List<Blame> responsible(@RequestParam @Valid @NotBlank(message = "来源ID不能为空") String originId) {
log.info("警务调查责任民警查询,来源ID: {}", originId);
Negative negative = negativeService.getByOriginId(originId);
if (Objects.isNull(negative)) {
return new ArrayList<>();
}
List<Blame> list = negativeBlameService.list(negative.getId());
log.info("警务调查责任民警查询,返回结果: {}", JSON.toJSONString(list));
return list;
}
}

30
src/main/java/com/biutag/supervision/controller/api/plugin/PetitionComplainApiController.java

@ -0,0 +1,30 @@
package com.biutag.supervision.controller.api.plugin;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.dto.DataPetitionComplaintDto;
import com.biutag.supervision.service.DataPetitionComplaintService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Tag(name = "信访投诉(插件)")
@RequiredArgsConstructor
@RequestMapping("plugin/petitionComplain")
@RestController
public class PetitionComplainApiController {
private final DataPetitionComplaintService dataPetitionComplaintService;
@Operation(summary = "推送信访投诉数据")
@PostMapping
public Result<Boolean> add(@RequestBody @Validated DataPetitionComplaintDto body) {
return Result.success(dataPetitionComplaintService.save(body));
}
}

10
src/main/java/com/biutag/supervision/controller/data/DataController.java

@ -0,0 +1,10 @@
package com.biutag.supervision.controller.data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.RestController;
@RequiredArgsConstructor
@RestController
public class DataController {
}

26
src/main/java/com/biutag/supervision/controller/sensitivePerception/ModelClassController.java

@ -0,0 +1,26 @@
package com.biutag.supervision.controller.sensitivePerception;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.ModelClass;
import com.biutag.supervision.service.ModelClassService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RequestMapping("modelClass")
@RequiredArgsConstructor
@RestController
public class ModelClassController {
private final ModelClassService modelClassService;
@GetMapping
public Result<List<ModelClass>> list() {
return Result.success(modelClassService.list(new LambdaQueryWrapper<ModelClass>().orderByAsc(ModelClass::getSort)));
}
}

47
src/main/java/com/biutag/supervision/controller/sensitivePerception/ModelController.java

@ -0,0 +1,47 @@
package com.biutag.supervision.controller.sensitivePerception;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.Model;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.pojo.param.ModelQueryParam;
import com.biutag.supervision.service.ModelService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.Objects;
@RequestMapping("model")
@RequiredArgsConstructor
@RestController
public class ModelController {
private final ModelService modelService;
@GetMapping
public Result<Page<Model>> list(ModelQueryParam queryParam) {
LambdaQueryWrapper<Model> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper
.like(StrUtil.isNotBlank(queryParam.getModelName()), Model::getModelName, queryParam.getModelName())
.eq(StrUtil.isNotBlank(queryParam.getDistributionMethod()), Model::getDistributionMethod, queryParam.getDistributionMethod())
.eq(Objects.nonNull(queryParam.getClassId()), Model::getClassId, queryParam.getClassId())
.orderByDesc(Model::getCreateTime);
return Result.success(modelService.page(new Page<>(queryParam.getCurrent(), queryParam.getSize()), queryWrapper));
}
@PostMapping
public Result<Void> add(@RequestBody Model model) {
model.setCreateTime(LocalDateTime.now());
model.setUpdateTime(LocalDateTime.now());
UserAuth user = UserContextHolder.getCurrentUser();
model.setCreateDepartId(user.getDepartId());
model.setCreateDepartName(user.getDepartName());
modelService.save(model);
return Result.success();
}
}

82
src/main/java/com/biutag/supervision/controller/system/DepartController.java

@ -0,0 +1,82 @@
package com.biutag.supervision.controller.system;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.biutag.supervision.constants.enums.DepartLevelEnum;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.SupDepart;
import com.biutag.supervision.pojo.param.DepartTreeListParam;
import com.biutag.supervision.pojo.vo.DepartTree;
import com.biutag.supervision.service.SupDepartService;
import jakarta.validation.ValidationException;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.Date;
import java.util.List;
@RequestMapping("depart")
@RequiredArgsConstructor
@RestController
public class DepartController {
private final SupDepartService departService;
@GetMapping
public Result<List<DepartTree>> treeList(DepartTreeListParam departTreeListParam) {
return Result.success(departService.buildTreeByParam(departTreeListParam));
}
@PostMapping
public Result<Boolean> add(@RequestBody SupDepart supDepart) {
if (departService.existsByName(supDepart.getName())) {
throw new ValidationException("部门全称已存在");
}
if (departService.existsByCode(supDepart.getCode())) {
throw new ValidationException("部门编码已存在");
}
SupDepart parent = departService.getById(supDepart.getPid());
supDepart.setId(String.valueOf(NumberUtil.nullToZero(departService.getMaxId()) + 1));
supDepart.setLevel(parent.getLevel() + 1);
supDepart.setUpdatedAt(DateUtil.format(new Date(), DatePattern.NORM_DATETIME_FORMAT));
return Result.success(departService.save(supDepart));
}
@PutMapping
public Result<Boolean> update(@RequestBody SupDepart supDepart) {
if (departService.exists(new LambdaQueryWrapper<SupDepart>().eq(SupDepart::getName, supDepart.getName()).ne(SupDepart::getId, supDepart.getId()))) {
throw new ValidationException("部门全程已存在");
}
if (departService.exists(new LambdaQueryWrapper<SupDepart>().eq(SupDepart::getCode, supDepart.getCode()).ne(SupDepart::getId, supDepart.getId()))) {
throw new ValidationException("部门编码已存在");
}
SupDepart parent = departService.getById(supDepart.getPid());
supDepart.setLevel(parent.getLevel() + 1);
supDepart.setUpdatedAt(DateUtil.format(new Date(), DatePattern.NORM_DATETIME_FORMAT));
return Result.success(departService.updateById(supDepart));
}
@DeleteMapping("{id}")
public Result<Boolean> del(@PathVariable String id) {
return Result.success(departService.removeById(id));
}
@GetMapping("tree")
public Result<List<DepartTree>> tree() {
return Result.success(departService.buildTree());
}
@GetMapping("second")
public Result<List<DepartTree>> list() {
List<SupDepart> supDeparts = departService.listByLevel(List.of(DepartLevelEnum.SECOND_CATEGORY.getValue(), DepartLevelEnum.SECOND.getValue()));
return Result.success(departService.buildTree(supDeparts));
}
@GetMapping("{departId}/children")
public Result<List<SupDepart>> children(@PathVariable String departId) {
return Result.success(departService.list(new LambdaQueryWrapper<SupDepart>().eq(SupDepart::getPid, departId).orderByAsc(SupDepart::getOrderNo)));
}
}

52
src/main/java/com/biutag/supervision/controller/system/DictContentController.java

@ -0,0 +1,52 @@
package com.biutag.supervision.controller.system;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.SupDictContent;
import com.biutag.supervision.pojo.vo.DictContentTree;
import com.biutag.supervision.service.SupDictContentService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
@RequiredArgsConstructor
@RequestMapping("dict/content")
@RestController
public class DictContentController {
private final SupDictContentService dictContentService;
@GetMapping("tree")
public Result<List<DictContentTree>> list() {
return Result.success(dictContentService.buildTree());
}
@PostMapping
public Result<Void> add(@RequestBody SupDictContent dictContent) {
dictContent.setUpdTime(LocalDateTime.now());
dictContent.setCrtTime(LocalDateTime.now());
dictContent.setStatus("0");
dictContentService.save(dictContent);
dictContentService.update(new LambdaUpdateWrapper<SupDictContent>().eq(SupDictContent::getId, dictContent.getId()).set(SupDictContent::getCode, dictContent.getId()));
return Result.success();
}
@PutMapping
public Result<Void> update(@RequestBody SupDictContent dictContent) {
dictContent.setUpdTime(LocalDateTime.now());
dictContentService.updateById(dictContent);
return Result.success();
}
@DeleteMapping("{id}")
public Result<Void> update(@PathVariable Integer id) {
if (dictContentService.exists(new LambdaQueryWrapper<SupDictContent>().eq(SupDictContent::getParentCode, id))) {
throw new RuntimeException("该节点下还存在子节点,无法删除");
}
dictContentService.removeById(id);
return Result.success();
}
}

74
src/main/java/com/biutag/supervision/controller/system/DictController.java

@ -0,0 +1,74 @@
package com.biutag.supervision.controller.system;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.dto.DictDataDto;
import com.biutag.supervision.pojo.dto.DictTypeDto;
import com.biutag.supervision.pojo.entity.SupDictData;
import com.biutag.supervision.pojo.entity.SupDictType;
import com.biutag.supervision.pojo.vo.DictContentTree;
import com.biutag.supervision.service.SupDictContentService;
import com.biutag.supervision.service.SupDictDataService;
import com.biutag.supervision.service.SupDictTypeService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RequiredArgsConstructor
@RequestMapping("dict")
@RestController
public class DictController {
private final SupDictTypeService dictTypeService;
private final SupDictDataService dictDataService;
@GetMapping
public Result<Page<SupDictType>> page(Page<SupDictType> page, String dictName) {
LambdaQueryWrapper<SupDictType> queryWrapper = new LambdaQueryWrapper<SupDictType>()
.like(StrUtil.isNotBlank(dictName), SupDictType::getDictName, dictName)
.orderByDesc(SupDictType::getUpdateTime);
return Result.success(dictTypeService.page(page, queryWrapper));
}
@PostMapping
public Result<Boolean> add(@RequestBody DictTypeDto dictType) {
return Result.success(dictTypeService.save(dictType));
}
@GetMapping("{dictType}/dictData")
public Result<Page<SupDictData>> list(Page<SupDictData> page, @PathVariable String dictType) {
return Result.success(dictDataService.page(page, new LambdaQueryWrapper<SupDictData>()
.eq(SupDictData::getDictType, dictType)
.orderByAsc(SupDictData::getDictSort)));
}
@PostMapping("{dictType}/dictData")
public Result<Boolean> add(@RequestBody DictDataDto dictData) {
return Result.success(dictDataService.save(dictData));
}
@PutMapping("{dictType}/dictData")
public Result<Boolean> update(@RequestBody DictDataDto dictData) {
SupDictData supDictData = new SupDictData();
BeanUtil.copyProperties(dictData, supDictData);
return Result.success(dictDataService.updateById(supDictData));
}
@DeleteMapping("{dictType}/dictData/{dictCode}")
public Result<Boolean> del(@PathVariable Integer dictCode) {
return Result.success(dictDataService.removeById(dictCode));
}
@GetMapping("data/{dictType}")
public Result<List<SupDictData>> list(@PathVariable String dictType) {
return Result.success(dictDataService.list(new LambdaQueryWrapper<SupDictData>()
.eq(SupDictData::getDictType, dictType)
.orderByAsc(SupDictData::getDictSort)));
}
}

46
src/main/java/com/biutag/supervision/controller/system/MenuController.java

@ -0,0 +1,46 @@
package com.biutag.supervision.controller.system;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.dto.MenuDto;
import com.biutag.supervision.pojo.entity.Menu;
import com.biutag.supervision.pojo.vo.MenuTree;
import com.biutag.supervision.service.MenuService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
@RequiredArgsConstructor
@RequestMapping("menu")
@RestController
public class MenuController {
private final MenuService menuService;
@GetMapping
public Result<List<MenuTree>> list() {
List<Menu> menus = menuService.list(new LambdaQueryWrapper<Menu>().orderByAsc(Menu::getMenuSort));
return Result.success(MenuTree.buildTree(menus));
}
@PostMapping
public Result<Void> add(@RequestBody MenuDto menuDto) {
Menu menu = new Menu();
BeanUtils.copyProperties(menuDto, menu);
menuService.save(menu);
return Result.success();
}
@PutMapping
public Result<List<MenuTree>> update(@RequestBody MenuDto menuDto) {
Menu menu = new Menu();
BeanUtils.copyProperties(menuDto, menu);
menu.setUpdateTime(LocalDateTime.now());
menuService.updateById(menu);
return Result.success();
}
}

70
src/main/java/com/biutag/supervision/controller/system/PoliceController.java

@ -0,0 +1,70 @@
package com.biutag.supervision.controller.system;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.domain.PoliceAuth;
import com.biutag.supervision.pojo.entity.NegDepartAuthority;
import com.biutag.supervision.pojo.entity.NegSourceAuthority;
import com.biutag.supervision.pojo.entity.SupPolice;
import com.biutag.supervision.pojo.model.PoliceModel;
import com.biutag.supervision.pojo.param.PoliceQueryParam;
import com.biutag.supervision.service.NegDepartAuthorityService;
import com.biutag.supervision.service.NegSourceAuthorityService;
import com.biutag.supervision.service.SupPoliceService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.Date;
import java.util.List;
@RequestMapping("police")
@RequiredArgsConstructor
@RestController
public class PoliceController {
private final SupPoliceService policeService;
private final NegDepartAuthorityService negDepartAuthorityService;
private final NegSourceAuthorityService negSourceAuthorityService;
@GetMapping
public Result<Page<PoliceModel>> list(PoliceQueryParam param) {
return Result.success(policeService.page(param));
}
@PostMapping
public Result<Boolean> add(@RequestBody SupPolice police) {
police.setId(IdUtil.getSnowflakeNextIdStr());
police.setUpdatedAt(String.valueOf(new Date().getTime()));
police.setCreatedAt(String.valueOf(new Date().getTime()));
return Result.success(policeService.save(police));
}
@PutMapping
public Result<Boolean> update(@RequestBody SupPolice police) {
police.setUpdatedAt(String.valueOf(new Date().getTime()));
return Result.success(policeService.updateById(police));
}
@GetMapping("{departId}/all")
public Result<List<SupPolice>> all(@PathVariable String departId) {
return Result.success(policeService.listAllByDepartId(departId));
}
@GetMapping("auth/{idCode}")
public Result<PoliceAuth> auth(@PathVariable String idCode) {
PoliceAuth policeAuth = new PoliceAuth().setDeparts(negDepartAuthorityService.list(idCode).stream().map(NegDepartAuthority::getDepartId).toList())
.setSources(negSourceAuthorityService.list(idCode).stream().map(NegSourceAuthority::getSource).toList());
return Result.success(policeAuth);
}
@PostMapping("auth/{idCode}")
public Result<Void> auth(@PathVariable String idCode, @RequestBody PoliceAuth policeAuth) {
negDepartAuthorityService.save(idCode, policeAuth.getDeparts());
negSourceAuthorityService.save(idCode, policeAuth.getSources());
return Result.success();
}
}

60
src/main/java/com/biutag/supervision/controller/system/RoleController.java

@ -0,0 +1,60 @@
package com.biutag.supervision.controller.system;
import cn.hutool.core.util.IdUtil;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.BaseRole;
import com.biutag.supervision.pojo.entity.RoleMenu;
import com.biutag.supervision.pojo.param.RoleQueryParam;
import com.biutag.supervision.service.BaseRoleService;
import com.biutag.supervision.service.RoleMenuService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
@RequiredArgsConstructor
@RequestMapping("role")
@RestController
public class RoleController {
private final BaseRoleService baseRoleService;
private final RoleMenuService roleMenuService;
@GetMapping
public Result<List<BaseRole>> list(RoleQueryParam roleQueryParam) {
List<BaseRole> roles = baseRoleService.list(roleQueryParam);
return Result.success(roles);
}
@PostMapping
public Result<Boolean> add(@RequestBody BaseRole role) {
role.setRoleId(String.valueOf(IdUtil.getSnowflakeNextId()));
role.setCreateTime(LocalDateTime.now());
role.setUpdateTime(LocalDateTime.now());
return Result.success(baseRoleService.save(role));
}
@PutMapping
public Result<Boolean> update(@RequestBody BaseRole role) {
role.setUpdateTime(LocalDateTime.now());
return Result.success(baseRoleService.updateById(role));
}
@DeleteMapping("{id}")
public Result<Boolean> del(@PathVariable String id) {
return Result.success(baseRoleService.removeById(id));
}
@GetMapping("{roleCode}/menu")
public Result<List<Integer>> add(@PathVariable String roleCode) {
return Result.success(roleMenuService.list(roleCode).stream().map(RoleMenu::getMenuId).toList());
}
@PostMapping("{roleCode}/menu")
public Result<Boolean> add(@PathVariable String roleCode, @RequestBody List<Integer> menuIds) {
return Result.success(roleMenuService.update(roleCode, menuIds));
}
}

30
src/main/java/com/biutag/supervision/controller/system/UserController.java

@ -0,0 +1,30 @@
package com.biutag.supervision.controller.system;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.dto.UserDto;
import com.biutag.supervision.pojo.model.UserModel;
import com.biutag.supervision.pojo.param.UserQueryParam;
import com.biutag.supervision.service.BaseUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
@RequiredArgsConstructor
@RequestMapping("user")
@RestController
public class UserController {
private final BaseUserService baseUserService;
@GetMapping
public Result<Page<UserModel>> list(UserQueryParam queryParam) {
Page<UserModel> baseUserPage = baseUserService.page(queryParam);
return Result.success(baseUserPage);
}
@PostMapping
public Result<Boolean> update(@RequestBody UserDto userDto) {
return Result.success(baseUserService.update(userDto));
}
}

25
src/main/java/com/biutag/supervision/controller/work/FlowNodeController.java

@ -0,0 +1,25 @@
package com.biutag.supervision.controller.work;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.FlowNode;
import com.biutag.supervision.service.FlowNodeService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RequestMapping("negative/flowNode")
@RequiredArgsConstructor
@RestController
public class FlowNodeController {
private final FlowNodeService flowNodeService;
@GetMapping
public Result<List<FlowNode>> list() {
return Result.success(flowNodeService.listAll());
}
}

49
src/main/java/com/biutag/supervision/controller/work/NegativeController.java

@ -0,0 +1,49 @@
package com.biutag.supervision.controller.work;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.biutag.supervision.flow.FlowService;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.domain.NegativeDetail;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.NegativeDto;
import com.biutag.supervision.pojo.param.NegativeQueryParam;
import com.biutag.supervision.pojo.vo.NegativeQueryVo;
import com.biutag.supervision.service.NegativeQueryService;
import com.biutag.supervision.service.NegativeService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
@RequiredArgsConstructor
@RequestMapping("negative")
@RestController
public class NegativeController {
private final NegativeService negativeService;
private final FlowService flowService;
private final NegativeQueryService negativeQueryService;
@GetMapping
public Result<Page<NegativeQueryVo>> list(NegativeQueryParam queryParam) {
return Result.success(negativeQueryService.page(queryParam));
}
@GetMapping("{id}")
public Result<NegativeDetail> get(@PathVariable String id, Integer workId) {
return Result.success(negativeService.get(id, workId));
}
@PostMapping
public Result<Boolean> add(@Valid @RequestBody NegativeDto negativeDto) {
return Result.success(negativeService.save(negativeDto));
}
@PostMapping("{id}/execute")
public Result<Boolean> execute(@PathVariable String id, @RequestBody ActionDto action) {
action.setNegativeId(id);
return Result.success(flowService.execute(action));
}
}

43
src/main/java/com/biutag/supervision/controller/work/NegativeFavController.java

@ -0,0 +1,43 @@
package com.biutag.supervision.controller.work;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.entity.NegativeFav;
import com.biutag.supervision.pojo.model.NegativeFavModel;
import com.biutag.supervision.pojo.param.WorkParam;
import com.biutag.supervision.service.NegativeFavService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
@RequestMapping("negative/fav")
@RequiredArgsConstructor
@RestController
public class NegativeFavController {
private final NegativeFavService favService;
@GetMapping
public Result<Page<NegativeFavModel>> list(WorkParam workParam) {
return Result.success(favService.page(workParam));
}
@PostMapping
public Result<Boolean> add(@RequestBody NegativeFav fav) {
fav.setCreateTime(LocalDateTime.now());
fav.setUserId(UserContextHolder.getCurrentUserId());
fav.setCreateTime(LocalDateTime.now());
return Result.success(favService.save(fav));
}
@DeleteMapping("{negativeId}")
public Result<Boolean> del(@PathVariable String negativeId) {
return Result.success(favService.remove(new LambdaQueryWrapper<NegativeFav>()
.eq(NegativeFav::getNegativeId, negativeId)
.eq(NegativeFav::getUserId, UserContextHolder.getCurrentUserId())));
}
}

31
src/main/java/com/biutag/supervision/controller/work/WorkController.java

@ -0,0 +1,31 @@
package com.biutag.supervision.controller.work;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.Result;
import com.biutag.supervision.pojo.model.NegativeWorkModel;
import com.biutag.supervision.pojo.param.WorkParam;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RequiredArgsConstructor
@RequestMapping("work")
@RestController
public class WorkController {
private final NegativeWorkService negativeWorkService;
@GetMapping("todo")
public Result<Page<NegativeWorkModel>> todo(WorkParam workParam) {
return Result.success(negativeWorkService.page(workParam, WorkStatusEnum.todo.name()));
}
@GetMapping("done")
public Result<Page<NegativeWorkModel>> done(WorkParam workParam) {
return Result.success(negativeWorkService.page(workParam, WorkStatusEnum.done.name()));
}
}

4
src/main/java/com/biutag/supervision/exception/AuthException.java

@ -0,0 +1,4 @@
package com.biutag.supervision.exception;
public class AuthException extends RuntimeException {
}

53
src/main/java/com/biutag/supervision/flow/FlowService.java

@ -0,0 +1,53 @@
package com.biutag.supervision.flow;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.flow.action.Action;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.entity.NegativeHistory;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeHistoryService;
import com.biutag.supervision.service.NegativeWorkService;
import com.biutag.supervision.util.JSON;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
@RequiredArgsConstructor
@Service
public class FlowService {
private final List<Action> actions;
private final NegativeHistoryService negativeHistoryService;
private final NegativeWorkService workService;
@Transactional(rollbackFor = Exception.class)
public Boolean execute(ActionDto actionDto) {
Action action = actions
.stream()
.filter(item -> item.getClass().getName().contains(StrUtil.upperFirst(StrUtil.toCamelCase(actionDto.getActionKey()))))
.findFirst()
.orElseThrow(() -> new RuntimeException("配置异常,请联系系统管理员"));
action.next(actionDto);
NegativeWork work = workService.getById(actionDto.getWorkId());
UserAuth user = UserContextHolder.getCurrentUser();
NegativeHistory history = new NegativeHistory().setHistoryId(IdUtil.fastSimpleUUID())
.setNegativeId(actionDto.getNegativeId())
.setActionName(actionDto.getActionName())
.setDepartName(work.getDepartName())
.setCrtUser(user.getUserId())
.setCrtUserName(user.getUserName())
.setCrtName(user.getNickName())
.setCrtTime(LocalDateTime.now())
.setDataJson(JSON.toJSONString(actionDto));
return negativeHistoryService.save(history);
}
}

9
src/main/java/com/biutag/supervision/flow/action/Action.java

@ -0,0 +1,9 @@
package com.biutag.supervision.flow.action;
import com.biutag.supervision.pojo.dto.ActionDto;
public interface Action {
void next(ActionDto actionDto);
}

177
src/main/java/com/biutag/supervision/flow/action/ApplyCompletionAction.java

@ -0,0 +1,177 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.constants.enums.*;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.VerifyData;
import com.biutag.supervision.pojo.entity.*;
import com.biutag.supervision.pojo.vo.FileVo;
import com.biutag.supervision.service.*;
import jakarta.validation.Validator;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
/**
* 申请办结
*/
@RequiredArgsConstructor
@Component
public class ApplyCompletionAction implements Action {
private final NegativeService negativeService;
private final NegativeBlameService negativeBlameService;
private final NegativeProblemRelationService negativeProblemRelationService;
private final NegativeFileService fileService;
private final NegativeApproveService aproveService;
private final NegativeWorkService workService;
private final SupDepartService departService;
private final Validator validator;
@Override
public void next(ActionDto actionDto) {
VerifyData verifyData = BeanUtil.toBean(actionDto.getData(), VerifyData.class);
validator.validate(verifyData);
// 新增审批数据
Negative negative = negativeService.getById(actionDto.getNegativeId());
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey(), verifyData, negative);
doneWork(actionDto.getWorkId());
if (!ApprovalFlowEnum.SECOND_APPROVAL.getValue().equals(negative.getApprovalFlow()) || !negative.getIsSecondHandle()) {
addWork(actionDto.getNegativeId(), actionDto.getWorkId(),
// 是否是本级办理
negative.getIsSecondHandle() ? RoleCodeEnum.FIRST_ADMIN.getCode() : RoleCodeEnum.SECOND_ADMIN.getCode(),
negative);
}
}
public void updateNegative(String negativeId, String nextFlowKey, VerifyData verifyData, Negative negative) {
LocalDateTime now = LocalDateTime.now();
LambdaUpdateWrapper<Negative> updateWrapper = new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, now)
.set(Negative::getProcessingStatus, ProcessingStatusEnum.approval.name())
.eq(Negative::getId, negativeId);
updateWrapper.set(Negative::getCheckStatus, verifyData.getCheckStatus())
.set(Negative::getCheckStatusDesc, verifyData.getCheckStatusDesc())
.set(Negative::getCheckStatusName, verifyData.getCheckStatusName())
.set(Negative::getIsRectifyCode, verifyData.getIsRectifyCode())
.set(Negative::getIsRectifyName, verifyData.getIsRectifyName())
.set(Negative::getAccountabilityTarget, verifyData.getAccountabilityTarget());
// 未整改
if (IsRectifyEnum.NOT.getValue().equals(verifyData.getIsRectifyCode())) {
updateWrapper.set(Negative::getRectifyRestrictionDays, verifyData.getRectifyRestrictionDays());
}
negativeService.update(updateWrapper);
if (!verifyData.getBlames().isEmpty()) {
List<NegativeProblemRelation> problemRelations = new ArrayList<>();
List<NegativeBlame> negativeBlames = verifyData.getBlames().stream().map(item -> {
NegativeBlame negativeBlame = new NegativeBlame();
BeanUtil.copyProperties(item, negativeBlame);
negativeBlame
.setBlameId(IdUtil.fastSimpleUUID())
.setNegativeId(negativeId)
.setCrtTime(now)
.setUpdTime(now);
if (Objects.nonNull(item.getAssistTime()) && item.getAssistTime().size() >= 2) {
negativeBlame.setAssistStartTime(item.getAssistTime().get(0))
.setAssistEndTime(item.getAssistTime().get(1));
}
problemRelations.addAll(item.getProblems().stream().map(problem -> {
NegativeProblemRelation problemRelation = new NegativeProblemRelation();
BeanUtil.copyProperties(problem, problemRelation);
problemRelation.setId(IdUtil.fastSimpleUUID());
problemRelation.setBlameId(negativeBlame.getBlameId());
problemRelation.setNegativeId(negativeId);
return problemRelation;
}).toList());
return negativeBlame;
}).toList();
// 先删除
negativeBlameService.remove(negativeId);
// 新增涉及人员
negativeBlameService.saveBatch(negativeBlames);
// 新增涉及人员问题类型
if (!problemRelations.isEmpty()) {
// 先删除
negativeProblemRelationService.remove(negativeId);
// 新增
negativeProblemRelationService.saveBatch(problemRelations);
}
}
if (!verifyData.getFiles().isEmpty()) {
List<NegativeFile> files = verifyData.getFiles().stream().map(item -> {
NegativeFile file = new NegativeFile();
BeanUtil.copyProperties(item, file);
file.setNegtiveId(negativeId);
return file;
}).toList();
// 先删除
fileService.remove(negativeId);
// 新增
fileService.saveBatch(files);
}
aproveService.remove(negativeId);
// 不是二级机构本级办理
if (!negative.getIsSecondHandle()) {
NegativeApprove approve1 = new NegativeApprove()
.setNegativeId(negativeId)
.setActionKey(FlowActionEnum.SECOND_APPROVE.getKey())
.setCreateTime(now);
aproveService.save(approve1);
}
// 三级审批 所队一>二級机构一>市局
if (!ApprovalFlowEnum.SECOND_APPROVAL.getValue().equals(negative.getApprovalFlow())) {
NegativeApprove approve2 = new NegativeApprove()
.setNegativeId(negativeId)
.setActionKey(FlowActionEnum.FIRST_APPROVE.getKey())
.setCreateTime(now);
aproveService.save(approve2);
}
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, Integer workId, String roleCode, Negative negative) {
NegativeWork currentWork = workService.getById(workId);
SupDepart depart = departService.getById(currentWork.getDepartId());
SupDepart parentDepart = departService.getById(depart.getPid());
workService.remove(new LambdaQueryWrapper<NegativeWork>()
.eq(NegativeWork::getNegativeId, negativeId)
.eq(NegativeWork::getRoleCode, roleCode)
.eq(NegativeWork::getDepartId, parentDepart.getId()));
NegativeWork work = new NegativeWork()
.setNegativeId(negativeId)
.setRoleCode(roleCode)
.setDepartId(parentDepart.getId())
.setDepartName(parentDepart.getName())
.setProblemSourcesCode(negative.getProblemSourcesCode())
.setCreateTime(LocalDateTime.now())
.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.save(work);
}
}

95
src/main/java/com/biutag/supervision/flow/action/ApplyExtensionAction.java

@ -0,0 +1,95 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.constants.enums.RoleCodeEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ExtensionApplyData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeExtensionApply;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.entity.SupDepart;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeExtensionApplyService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import com.biutag.supervision.service.SupDepartService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 申请延期
*/
@RequiredArgsConstructor
@Component
public class ApplyExtensionAction implements Action {
private final NegativeService negativeService;
private final NegativeExtensionApplyService extensionApplyService;
private final NegativeWorkService workService;
private final SupDepartService departService;
@Override
public void next(ActionDto actionDto) {
ExtensionApplyData extensionApplyData = BeanUtil.toBean(actionDto.getData(), ExtensionApplyData.class);
NegativeExtensionApply extensionApply = addExtensionApply(actionDto, extensionApplyData);
updateNegative(actionDto.getNegativeId(), extensionApply.getId());
addWork(actionDto, RoleCodeEnum.SECOND_ADMIN.getCode());
}
public NegativeExtensionApply addExtensionApply(ActionDto actionDto, ExtensionApplyData applyExtensionData) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(actionDto.getWorkId());
NegativeExtensionApply extensionApply = new NegativeExtensionApply()
.setNegativeId(actionDto.getNegativeId())
.setComments(applyExtensionData.getComments())
.setExtensionDays(applyExtensionData.getExtensionDays())
.setHandlerDepartId(work.getDepartId())
.setHandlerDepartName(work.getDepartName())
.setHandlerUserName(user.getUserName())
.setHandlerName(user.getNickName())
.setCreateTime(LocalDateTime.now());
extensionApplyService.save(extensionApply);
return extensionApply;
}
public void updateNegative(String negativeId, Integer negativeExtensionApplyId) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getUpdTime, LocalDateTime.now())
.set(Negative::getNegativeExtensionApplyId, negativeExtensionApplyId)
.set(Negative::getExtensionApplyFlag, false)
.eq(Negative::getId, negativeId));
}
public void addWork(ActionDto actionDto, String roleCode) {
NegativeWork currentWork = workService.getById(actionDto.getWorkId());
SupDepart depart = departService.getById(currentWork.getDepartId());
SupDepart parentDepart = departService.getById(depart.getPid());
workService.remove(new LambdaQueryWrapper<NegativeWork>()
.eq(NegativeWork::getNegativeId, actionDto.getNegativeId())
.eq(NegativeWork::getRoleCode, roleCode)
.eq(NegativeWork::getDepartId, parentDepart.getId()));
Negative negative = negativeService.getById(actionDto.getNegativeId());
NegativeWork work = new NegativeWork()
.setNegativeId(actionDto.getNegativeId())
.setRoleCode(roleCode)
.setDepartId(parentDepart.getId())
.setDepartName(parentDepart.getName())
.setProblemSourcesCode(negative.getProblemSourcesCode())
.setFlowKey(actionDto.getNextFlowKey())
.setCreateTime(LocalDateTime.now())
.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.save(work);
}
}

77
src/main/java/com/biutag/supervision/flow/action/FirstApproveAction.java

@ -0,0 +1,77 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.ApproveStateEnum;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 市局审批通过
*/
@RequiredArgsConstructor
@Component
public class FirstApproveAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
private final NegativeApproveService approveService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
updateApprove(actionDto.getNegativeId(), actionDto.getActionKey(), actionDto.getWorkId(), approveData.getComments());
doneWork(actionDto.getWorkId());
}
public void updateNegative(String negativeId, String nextFlowKey) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getProcessingStatus, ProcessingStatusEnum.completed.name())
.set(Negative::getCompleteDate, LocalDateTime.now())
.set(Negative::getUpdTime, LocalDateTime.now())
.eq(Negative::getId, negativeId));
}
public void updateApprove(String negativeId, String actionKey, Integer workId, String comments) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(workId);
approveService.update(new LambdaUpdateWrapper<NegativeApprove>()
.set(NegativeApprove::getState, ApproveStateEnum.approved.name())
.set(NegativeApprove::getComments, comments)
.set(NegativeApprove::getHandlerDepartId, work.getDepartId())
.set(NegativeApprove::getHandlerDepartName, work.getDepartName())
.set(NegativeApprove::getHandlerUserName, user.getUserName())
.set(NegativeApprove::getHandlerName, user.getNickName())
.set(NegativeApprove::getUpdateTime, LocalDateTime.now())
.eq(NegativeApprove::getNegativeId, negativeId)
.eq(NegativeApprove::getActionKey, actionKey));
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.eq(NegativeWork::getId, workId));
}
}

81
src/main/java/com/biutag/supervision/flow/action/FirstApproveReturnAction.java

@ -0,0 +1,81 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.*;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 市局 退回整改
*/
@RequiredArgsConstructor
@Component
public class FirstApproveReturnAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
private final NegativeApproveService approveService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
addApprove(actionDto.getNegativeId(), approveData.getComments(), actionDto.getWorkId());
doneWork(actionDto.getWorkId());
addWork(actionDto.getNegativeId(), RoleCodeEnum.SECOND_ADMIN.getCode());
}
public void updateNegative(String negativeId, String nextFlowKey) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, LocalDateTime.now())
.eq(Negative::getId, negativeId));
}
public void addApprove(String negativeId, String comments, Integer workId) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(workId);
approveService.update(new LambdaUpdateWrapper<NegativeApprove>()
.set(NegativeApprove::getState, ApproveStateEnum.rejected.name())
.set(NegativeApprove::getComments, comments)
.set(NegativeApprove::getHandlerDepartId, work.getDepartId())
.set(NegativeApprove::getHandlerDepartName, work.getDepartName())
.set(NegativeApprove::getHandlerUserName, user.getUserName())
.set(NegativeApprove::getHandlerName, user.getNickName())
.set(NegativeApprove::getUpdateTime, LocalDateTime.now())
.eq(NegativeApprove::getNegativeId, negativeId)
.eq(NegativeApprove::getActionKey, FlowActionEnum.FIRST_APPROVE.getKey()));
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, String roleCode) {
NegativeWork work = workService.getOne(new LambdaQueryWrapper<NegativeWork>()
.eq(NegativeWork::getNegativeId, negativeId)
.eq(NegativeWork::getRoleCode, roleCode));
work.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.updateById(work);
}
}

109
src/main/java/com/biutag/supervision/flow/action/FirstDistributeAction.java

@ -0,0 +1,109 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.constants.enums.*;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.FirstDistributeData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.entity.SupDepart;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import com.biutag.supervision.service.SupDepartService;
import jakarta.validation.Validator;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import java.time.LocalDateTime;
/**
* 市局下发
*/
@Validated
@RequiredArgsConstructor
@Component
public class FirstDistributeAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
private final SupDepartService departService;
private final Validator validator;
@Override
public void next(ActionDto actionDto) {
FirstDistributeData firstDistributeData = BeanUtil.toBean(actionDto.getData(), FirstDistributeData.class);
validator.validate(firstDistributeData);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey(), firstDistributeData);
doneWork(actionDto.getWorkId());
addWork(actionDto.getNegativeId(),
HostLevelEnums.THREE.getValue().equals(firstDistributeData.getHostLevel()) ? RoleCodeEnum.THREE_ADMIN.getCode() : RoleCodeEnum.SECOND_ADMIN.getCode(),
firstDistributeData.getDepartId(), firstDistributeData.getDepartName());
}
public void updateNegative(String negativeId, String nextFlowKey, @Validated FirstDistributeData distributeData) {
LocalDateTime now = LocalDateTime.now();
LambdaUpdateWrapper<Negative> updateWrapper = new LambdaUpdateWrapper<Negative>()
.set(Negative::getHostLevel, distributeData.getHostLevel())
.set(Negative::getTimeLimit, distributeData.getTimeLimit())
.set(Negative::getApprovalFlow, distributeData.getApprovalFlow())
.set(Negative::getFirstDistributeTime, now)
.set(Negative::getUpdTime, now)
.eq(Negative::getId, negativeId);
if (TimeLimitEnum.OTHER.getValue().equals(distributeData.getTimeLimit())) {
updateWrapper.set(Negative::getMaxSignDuration, distributeData.getMaxSignDuration())
.set(Negative::getMaxHandleDuration, distributeData.getMaxHandleDuration())
.set(Negative::getMaxExtensionDuration, distributeData.getMaxExtensionDuration());
} else {
TimeLimitEnum timeLimitEnum = TimeLimitEnum.get(distributeData.getTimeLimit());
updateWrapper.set(Negative::getMaxSignDuration, timeLimitEnum.getMaxSignDuration())
.set(Negative::getMaxHandleDuration, timeLimitEnum.getMaxHandleDuration())
.set(Negative::getMaxExtensionDuration, timeLimitEnum.getMaxExtensionDuration());
}
if (HostLevelEnums.THREE.getValue().equals(distributeData.getHostLevel())) {
SupDepart parentDepart = departService.getParentDepart(distributeData.getDepartId());
updateWrapper.set(Negative::getFlowKey, FlowNodeEnum.THREE_SIGN.getKey())
.set(Negative::getHandleSecondDepartId, parentDepart.getId())
.set(Negative::getHandleSecondDepartName, parentDepart.getShortName())
.set(Negative::getHandleThreeDepartId, distributeData.getDepartId())
.set(Negative::getHandleThreeDepartName, distributeData.getDepartName());
} else {
updateWrapper.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getHandleSecondDepartId, distributeData.getDepartId())
.set(Negative::getHandleSecondDepartName, distributeData.getDepartName());
}
negativeService.update(updateWrapper);
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, String roleCode, String departId, String departName) {
workService.remove(new LambdaQueryWrapper<NegativeWork>()
.eq(NegativeWork::getNegativeId, negativeId)
.eq(NegativeWork::getRoleCode, roleCode)
.eq(NegativeWork::getDepartId, departId));
Negative negative = negativeService.getById(negativeId);
NegativeWork work = new NegativeWork()
.setNegativeId(negativeId)
.setRoleCode(roleCode)
.setDepartId(departId)
.setDepartName(departName)
.setProblemSourcesCode(negative.getProblemSourcesCode())
.setCreateTime(LocalDateTime.now())
.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.save(work);
}
}

81
src/main/java/com/biutag/supervision/flow/action/FirstExtensionApproveAction.java

@ -0,0 +1,81 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.NumberUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.ApproveStateEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeExtensionApply;
import com.biutag.supervision.pojo.entity.NegativeExtensionApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeExtensionApplyService;
import com.biutag.supervision.service.NegativeExtensionApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 市局申请延期审批通过
*/
@RequiredArgsConstructor
@Component
public class FirstExtensionApproveAction implements Action {
private final NegativeService negativeService;
private final NegativeExtensionApplyService extensionApplyService;
private final NegativeExtensionApproveService extensionApproveService;
private final NegativeWorkService workService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
Negative negative = negativeService.getById(actionDto.getNegativeId());
addExtensionApprove(actionDto, approveData.getComments(), negative.getNegativeExtensionApplyId());
doneWork(actionDto.getWorkId());
}
public void updateNegative(Negative negative) {
NegativeExtensionApply extensionApply = extensionApplyService.getById(negative.getNegativeExtensionApplyId());
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getExtensionApplyFlag, true)
// 延期天数
.set(Negative::getExtensionDays, NumberUtil.nullToZero(negative.getExtensionDays()) + extensionApply.getExtensionDays())
.eq(Negative::getId, negative.getId()));
}
public void addExtensionApprove(ActionDto actionDto, String comments, Integer negativeExtensionApplyId) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(actionDto.getWorkId());
NegativeExtensionApprove extensionApprove = new NegativeExtensionApprove()
.setNegativeId(actionDto.getNegativeId())
.setNegativeExtensionApplyId(negativeExtensionApplyId)
.setComments(comments)
.setHandlerDepartId(work.getDepartId())
.setHandlerDepartName(work.getDepartName())
.setHandlerUserName(user.getUserName())
.setHandlerName(user.getNickName())
.setState(ApproveStateEnum.approved.name())
.setCreateTime(LocalDateTime.now());
extensionApproveService.save(extensionApprove);
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>().set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getFlowKey, null)
.eq(NegativeWork::getId, workId));
}
}

70
src/main/java/com/biutag/supervision/flow/action/FirstExtensionReturnAction.java

@ -0,0 +1,70 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.ApproveStateEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeExtensionApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeExtensionApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 市局申请延期审批驳回
*/
@RequiredArgsConstructor
@Component
public class FirstExtensionReturnAction implements Action {
private final NegativeService negativeService;
private final NegativeExtensionApproveService extensionApproveService;
private final NegativeWorkService workService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
updateNegative(actionDto.getNegativeId());
addExtensionApprove(actionDto, approveData.getComments());
doneWork(actionDto.getWorkId());
}
public void updateNegative(String negativeId) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getExtensionApplyFlag, true)
.eq(Negative::getId, negativeId));
}
public void addExtensionApprove(ActionDto actionDto, String comments) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(actionDto.getWorkId());
NegativeExtensionApprove extensionApprove = new NegativeExtensionApprove()
.setNegativeId(actionDto.getNegativeId())
.setComments(comments)
.setHandlerDepartId(work.getDepartId())
.setHandlerDepartName(work.getDepartName())
.setHandlerUserName(user.getUserName())
.setHandlerName(user.getNickName())
.setState(ApproveStateEnum.rejected.name())
.setCreateTime(LocalDateTime.now());
extensionApproveService.save(extensionApprove);
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>().set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getFlowKey, null)
.eq(NegativeWork::getId, workId));
}
}

91
src/main/java/com/biutag/supervision/flow/action/SaveAction.java

@ -0,0 +1,91 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.constants.enums.InspectCaseEnum;
import com.biutag.supervision.constants.enums.IsRectifyEnum;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.VerifyData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeBlame;
import com.biutag.supervision.pojo.entity.NegativeProblemRelation;
import com.biutag.supervision.service.NegativeBlameService;
import com.biutag.supervision.service.NegativeProblemRelationService;
import com.biutag.supervision.service.NegativeService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 核查办理-保存
*/
@RequiredArgsConstructor
@Component
public class SaveAction implements Action {
private final NegativeService negativeService;
private final NegativeBlameService negativeBlameService;
private final NegativeProblemRelationService negativeProblemRelationService;
@Override
public void next(ActionDto actionDto) {
VerifyData verifyData = BeanUtil.toBean(actionDto.getData(), VerifyData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey(), verifyData);
}
public void updateNegative(String negativeId, String nextFlowKey, VerifyData verifyData) {
LambdaUpdateWrapper<Negative> updateWrapper = new LambdaUpdateWrapper<Negative>()
.set(Negative::getUpdTime, LocalDateTime.now())
.set(Negative::getProcessingStatus, ProcessingStatusEnum.approval.name())
.eq(Negative::getId, negativeId);
updateWrapper.set(Negative::getCheckStatus, verifyData.getCheckStatus())
.set(Negative::getCheckStatusName, verifyData.getCheckStatusName());
// 核查情况是否属实
if (InspectCaseEnum.isItTure(verifyData.getCheckStatus())) {
updateWrapper.set(Negative::getIsRectifyCode, verifyData.getIsRectifyCode())
.set(Negative::getIsRectifyName, verifyData.getIsRectifyName())
.set(Negative::getAccountabilityTarget, verifyData.getAccountabilityTarget());
// 未整改
if (IsRectifyEnum.NOT.getValue().equals(verifyData.getIsRectifyCode())) {
updateWrapper.set(Negative::getRectifyRestrictionDays, verifyData.getRectifyRestrictionDays());
}
}
negativeService.update(updateWrapper);
if (!verifyData.getBlames().isEmpty()) {
negativeBlameService.remove(negativeId);
List<NegativeProblemRelation> problemRelations = new ArrayList<>();
List<NegativeBlame> negativeBlames = verifyData.getBlames().stream().map(item -> {
NegativeBlame negativeBlame = new NegativeBlame();
BeanUtil.copyProperties(item, negativeBlame);
negativeBlame.setNegativeId(negativeId)
.setBlameId(IdUtil.fastSimpleUUID())
.setCrtTime(LocalDateTime.now())
.setUpdTime(LocalDateTime.now());
problemRelations.addAll(item.getProblems().stream().map(problem -> {
NegativeProblemRelation problemRelation = new NegativeProblemRelation();
BeanUtil.copyProperties(problem, problemRelation);
problemRelation.setId(IdUtil.fastSimpleUUID());
problemRelation.setBlameId(negativeBlame.getBlameId());
problemRelation.setNegativeId(negativeId);
return problemRelation;
}).toList());
return negativeBlame;
}).toList();
// 新增涉及人员
negativeBlameService.saveBatch(negativeBlames);
// 新增涉及人员问题类型
if (!problemRelations.isEmpty()) {
negativeProblemRelationService.remove(negativeId);
negativeProblemRelationService.saveBatch(problemRelations);
}
}
}
}

103
src/main/java/com/biutag/supervision/flow/action/SecondApproveAction.java

@ -0,0 +1,103 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.AppConstants;
import com.biutag.supervision.constants.enums.*;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 二级机构审批通过
*/
@RequiredArgsConstructor
@Component
public class SecondApproveAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
private final NegativeApproveService approveService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
updateApprove(actionDto.getNegativeId(), actionDto.getActionKey(), approveData.getComments(), actionDto.getWorkId());
doneWork(actionDto.getWorkId());
Negative negative = negativeService.getById(actionDto.getNegativeId());
if (ApprovalFlowEnum.THREE_APPROVAL.getValue().equals(negative.getApprovalFlow())) {
addWork(actionDto.getNegativeId(), RoleCodeEnum.FIRST_ADMIN.getCode());
}
}
public void updateNegative(String negativeId, String nextFlowKey) {
LambdaUpdateWrapper<Negative> updateWrapper = new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, LocalDateTime.now())
.eq(Negative::getId, negativeId);
Negative negative = negativeService.getById(negativeId);
if (ApprovalFlowEnum.SECOND_APPROVAL.getValue().equals(negative.getApprovalFlow())) {
updateWrapper.set(Negative::getFlowKey, FlowNodeEnum.COMPLETED.getKey())
.set(Negative::getProcessingStatus, ProcessingStatusEnum.completed.name())
.set(Negative::getCompleteDate, LocalDateTime.now());
} else {
updateWrapper.set(Negative::getFlowKey, nextFlowKey);
}
negativeService.update(updateWrapper);
}
public void updateApprove(String negativeId, String actionKey, String comments, Integer workId) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(workId);
approveService.update(new LambdaUpdateWrapper<NegativeApprove>()
.set(NegativeApprove::getState, ApproveStateEnum.approved.name())
.set(NegativeApprove::getComments, comments)
.set(NegativeApprove::getHandlerDepartId, work.getDepartId())
.set(NegativeApprove::getHandlerDepartName, work.getDepartName())
.set(NegativeApprove::getHandlerUserName, user.getUserName())
.set(NegativeApprove::getHandlerName, user.getNickName())
.set(NegativeApprove::getUpdateTime, LocalDateTime.now())
.eq(NegativeApprove::getNegativeId, negativeId)
.eq(NegativeApprove::getActionKey, actionKey));
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, String roleCode) {
workService.remove(new LambdaQueryWrapper<NegativeWork>()
.eq(NegativeWork::getNegativeId, negativeId)
.eq(NegativeWork::getRoleCode, roleCode)
.eq(NegativeWork::getDepartId, AppConstants.ROOT_DEPART_ID));
Negative negative = negativeService.getById(negativeId);
NegativeWork work = new NegativeWork()
.setNegativeId(negativeId)
.setRoleCode(roleCode)
.setDepartId(AppConstants.ROOT_DEPART_ID)
.setProblemSourcesCode(negative.getProblemSourcesCode())
.setCreateTime(LocalDateTime.now())
.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.save(work);
}
}

82
src/main/java/com/biutag/supervision/flow/action/SecondApproveReturnAction.java

@ -0,0 +1,82 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.*;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.FlowAction;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 二级机构 退回整改
*/
@RequiredArgsConstructor
@Component
public class SecondApproveReturnAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
private final NegativeApproveService approveService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
updateApprove(actionDto.getNegativeId(), approveData.getComments(), actionDto.getWorkId());
doneWork(actionDto.getWorkId());
addWork(actionDto.getNegativeId(), RoleCodeEnum.THREE_ADMIN.getCode());
}
public void updateNegative(String negativeId, String nextFlowKey) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, LocalDateTime.now())
.set(Negative::getProcessingStatus, ProcessingStatusEnum.processing.name())
.eq(Negative::getId, negativeId));
}
public void updateApprove(String negativeId, String comments, Integer workId) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(workId);
approveService.update(new LambdaUpdateWrapper<NegativeApprove>()
.set(NegativeApprove::getState, ApproveStateEnum.rejected.name())
.set(NegativeApprove::getComments, comments)
.set(NegativeApprove::getHandlerDepartId, work.getDepartId())
.set(NegativeApprove::getHandlerDepartName, work.getDepartName())
.set(NegativeApprove::getHandlerUserName, user.getUserName())
.set(NegativeApprove::getHandlerName, user.getNickName())
.set(NegativeApprove::getUpdateTime, LocalDateTime.now())
.eq(NegativeApprove::getNegativeId, negativeId)
.eq(NegativeApprove::getActionKey, FlowActionEnum.SECOND_APPROVE.getKey()));
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, String roleCode) {
NegativeWork work = workService.getOne(new LambdaQueryWrapper<NegativeWork>().eq(NegativeWork::getNegativeId, negativeId).eq(NegativeWork::getRoleCode, roleCode));
work.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.updateById(work);
}
}

74
src/main/java/com/biutag/supervision/flow/action/SecondDistributeAction.java

@ -0,0 +1,74 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.constants.enums.RoleCodeEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.FirstDistributeData;
import com.biutag.supervision.pojo.dto.flow.SecondDistributeData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 二级机构下发
*/
@RequiredArgsConstructor
@Component
public class SecondDistributeAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
@Override
public void next(ActionDto actionDto) {
SecondDistributeData secondDistributeData = BeanUtil.toBean(actionDto.getData(), SecondDistributeData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey(), secondDistributeData);
doneWork(actionDto.getWorkId());
addWork(actionDto.getNegativeId(), RoleCodeEnum.THREE_ADMIN.getCode(), secondDistributeData.getDepartId(), secondDistributeData.getDepartName());
}
public void updateNegative(String negativeId, String nextFlowKey, SecondDistributeData secondDistributeData) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getHandleThreeDepartId, secondDistributeData.getDepartId())
.set(Negative::getHandleThreeDepartName, secondDistributeData.getDepartName())
.set(Negative::getUpdTime, LocalDateTime.now())
.set(Negative::getUpdTime, LocalDateTime.now())
.eq(Negative::getId, negativeId));
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, String roleCode, String departId, String departName) {
workService.remove(new LambdaQueryWrapper<NegativeWork>()
.eq(NegativeWork::getNegativeId, negativeId)
.eq(NegativeWork::getRoleCode, roleCode)
.eq(NegativeWork::getDepartId, departId));
Negative negative = negativeService.getById(negativeId);
NegativeWork work = new NegativeWork()
.setNegativeId(negativeId)
.setRoleCode(roleCode)
.setDepartId(departId)
.setDepartName(departName)
.setProblemSourcesCode(negative.getProblemSourcesCode())
.setCreateTime(LocalDateTime.now())
.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.save(work);
}
}

88
src/main/java/com/biutag/supervision/flow/action/SecondExtensionApproveAction.java

@ -0,0 +1,88 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.AppConstants;
import com.biutag.supervision.constants.enums.ApproveStateEnum;
import com.biutag.supervision.constants.enums.RoleCodeEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeExtensionApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeExtensionApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 二级机构申请延期审批通过
*/
@RequiredArgsConstructor
@Component
public class SecondExtensionApproveAction implements Action {
private final NegativeService negativeService;
private final NegativeExtensionApproveService extensionApproveService;
private final NegativeWorkService workService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
addExtensionApprove(actionDto, approveData.getComments());
doneWork(actionDto.getWorkId());
addWork(actionDto, RoleCodeEnum.FIRST_ADMIN.getCode(), actionDto.getNextFlowKey());
}
public void addExtensionApprove(ActionDto actionDto, String comments) {
Negative negative = negativeService.getById(actionDto.getNegativeId());
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(actionDto.getWorkId());
NegativeExtensionApprove extensionApprove = new NegativeExtensionApprove()
.setNegativeId(actionDto.getNegativeId())
.setNegativeExtensionApplyId(negative.getNegativeExtensionApplyId())
.setComments(comments)
.setHandlerDepartId(work.getDepartId())
.setHandlerDepartName(work.getDepartName())
.setHandlerUserName(user.getUserName())
.setHandlerName(user.getNickName())
.setState(ApproveStateEnum.approved.name())
.setCreateTime(LocalDateTime.now());
extensionApproveService.save(extensionApprove);
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>().set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getFlowKey, null)
.eq(NegativeWork::getId, workId));
}
public void addWork(ActionDto actionDto, String roleCode, String nextFlowKey) {
workService.remove(new LambdaQueryWrapper<NegativeWork>()
.eq(NegativeWork::getNegativeId, actionDto.getNegativeId())
.eq(NegativeWork::getRoleCode, roleCode)
.eq(NegativeWork::getDepartId, AppConstants.ROOT_DEPART_ID));
Negative negative = negativeService.getById(actionDto.getNegativeId());
NegativeWork work = new NegativeWork()
.setNegativeId(actionDto.getNegativeId())
.setRoleCode(roleCode)
.setFlowKey(actionDto.getNextFlowKey())
.setDepartId(AppConstants.ROOT_DEPART_ID)
.setDepartName(AppConstants.ROOT_DEPART_NAME)
.setProblemSourcesCode(negative.getProblemSourcesCode())
.setFlowKey(nextFlowKey)
.setCreateTime(LocalDateTime.now())
.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.save(work);
}
}

70
src/main/java/com/biutag/supervision/flow/action/SecondExtensionReturnAction.java

@ -0,0 +1,70 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.ApproveStateEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.ApproveData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeExtensionApprove;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeExtensionApproveService;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 二级机构申请延期审批驳回
*/
@RequiredArgsConstructor
@Component
public class SecondExtensionReturnAction implements Action {
private final NegativeService negativeService;
private final NegativeExtensionApproveService extensionApproveService;
private final NegativeWorkService workService;
@Override
public void next(ActionDto actionDto) {
ApproveData approveData = BeanUtil.toBean(actionDto.getData(), ApproveData.class);
updateNegative(actionDto.getNegativeId());
addExtensionApprove(actionDto, approveData.getComments());
doneWork(actionDto.getWorkId());
}
public void updateNegative(String negativeId) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getExtensionApplyFlag, true)
.eq(Negative::getId, negativeId));
}
public void addExtensionApprove(ActionDto actionDto, String comments) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(actionDto.getWorkId());
NegativeExtensionApprove extensionApprove = new NegativeExtensionApprove()
.setNegativeId(actionDto.getNegativeId())
.setComments(comments)
.setHandlerDepartId(work.getDepartId())
.setHandlerDepartName(work.getDepartName())
.setHandlerUserName(user.getUserName())
.setHandlerName(user.getNickName())
.setState(ApproveStateEnum.rejected.name())
.setCreateTime(LocalDateTime.now());
extensionApproveService.save(extensionApprove);
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>().set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getFlowKey, null)
.eq(NegativeWork::getId, workId));
}
}

31
src/main/java/com/biutag/supervision/flow/action/SecondLocalProcessingAction.java

@ -0,0 +1,31 @@
package com.biutag.supervision.flow.action;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.service.NegativeService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
@RequiredArgsConstructor
@Component
public class SecondLocalProcessingAction implements Action {
private final NegativeService negativeService;
@Override
public void next(ActionDto actionDto) {
updateNegative(actionDto);
}
public void updateNegative(ActionDto actionDto) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, actionDto.getNextFlowKey())
.set(Negative::getIsSecondHandle, true)
.set(Negative::getUpdTime, LocalDateTime.now())
.eq(Negative::getId, actionDto.getNegativeId()));
}
}

45
src/main/java/com/biutag/supervision/flow/action/SecondSignAction.java

@ -0,0 +1,45 @@
package com.biutag.supervision.flow.action;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 二级机构签收
*/
@RequiredArgsConstructor
@Component
public class SecondSignAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
@Override
public void next(ActionDto actionDto) {
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
updateWork(actionDto.getWorkId());
}
public void updateNegative(String negativeId, String nextFlowKey) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, LocalDateTime.now())
.eq(Negative::getId, negativeId));
}
public void updateWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.eq(NegativeWork::getId, workId));
}
}

81
src/main/java/com/biutag/supervision/flow/action/SecondSignReturnAction.java

@ -0,0 +1,81 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.RoleCodeEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.SignReturnData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeSignReturn;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeSignReturnService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 二级机构问题退回
*/
@RequiredArgsConstructor
@Component
public class SecondSignReturnAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
private final NegativeSignReturnService signReturnService;
@Override
public void next(ActionDto actionDto) {
SignReturnData signReturnData = BeanUtil.toBean(actionDto.getData(), SignReturnData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
addSignReturn(actionDto, signReturnData.getComments());
doneWork(actionDto.getWorkId());
addWork(actionDto.getNegativeId(), RoleCodeEnum.FIRST_ADMIN.getCode());
}
public void updateNegative(String negativeId, String nextFlowKey) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, LocalDateTime.now())
.eq(Negative::getId, negativeId));
}
public void addSignReturn(ActionDto actionDto, String comments) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(actionDto.getWorkId());
NegativeSignReturn signReturn = new NegativeSignReturn()
.setNegativeId(actionDto.getNegativeId())
.setActionKey(actionDto.getActionKey())
.setComments(comments)
.setHandlerDepartId(work.getDepartId())
.setHandlerDepartName(work.getDepartName())
.setHandlerUserName(user.getUserName())
.setHandlerName(user.getNickName())
.setCreateTime(LocalDateTime.now());
signReturnService.save(signReturn);
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, String roleCode) {
NegativeWork work = workService.getOne(new LambdaQueryWrapper<NegativeWork>().eq(NegativeWork::getNegativeId, negativeId).eq(NegativeWork::getRoleCode, roleCode));
work.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.updateById(work);
}
}

46
src/main/java/com/biutag/supervision/flow/action/ThreeSignAction.java

@ -0,0 +1,46 @@
package com.biutag.supervision.flow.action;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.NegativeWorkService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 三级机构签收
*/
@RequiredArgsConstructor
@Component
public class ThreeSignAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
@Override
public void next(ActionDto actionDto) {
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
updateWork(actionDto.getWorkId());
}
public void updateNegative(String negativeId, String nextFlowKey) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, LocalDateTime.now())
.set(Negative::getProcessingStatus, ProcessingStatusEnum.processing.name())
.eq(Negative::getId, negativeId));
}
public void updateWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.eq(NegativeWork::getId, workId));
}
}

96
src/main/java/com/biutag/supervision/flow/action/ThreeSignReturnAction.java

@ -0,0 +1,96 @@
package com.biutag.supervision.flow.action;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.common.UserContextHolder;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.constants.enums.RoleCodeEnum;
import com.biutag.supervision.constants.enums.WorkStatusEnum;
import com.biutag.supervision.pojo.dto.ActionDto;
import com.biutag.supervision.pojo.dto.flow.SignReturnData;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.NegativeSignReturn;
import com.biutag.supervision.pojo.entity.NegativeWork;
import com.biutag.supervision.pojo.model.UserAuth;
import com.biutag.supervision.service.*;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 三级机构问题退回
*/
@RequiredArgsConstructor
@Component
public class ThreeSignReturnAction implements Action {
private final NegativeService negativeService;
private final NegativeWorkService workService;
private final NegativeSignReturnService signReturnService;
private final NegativeBlameService blameService;
private final NegativeProblemRelationService problemRelationService;
@Override
public void next(ActionDto actionDto) {
SignReturnData signReturnData = BeanUtil.toBean(actionDto.getData(), SignReturnData.class);
updateNegative(actionDto.getNegativeId(), actionDto.getNextFlowKey());
addSignReturn(actionDto, signReturnData.getComments());
doneWork(actionDto.getWorkId());
addWork(actionDto.getNegativeId(), RoleCodeEnum.SECOND_ADMIN.getCode());
}
public void updateNegative(String negativeId, String nextFlowKey) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getFlowKey, nextFlowKey)
.set(Negative::getUpdTime, LocalDateTime.now())
.set(Negative::getProcessingStatus, ProcessingStatusEnum.signing.name())
//-----------------------------------------------------------------------------
.set(Negative::getCheckStatus, null)
.set(Negative::getCheckStatusName, null)
.set(Negative::getIsRectifyCode, null)
.set(Negative::getIsRectifyName, null)
.set(Negative::getAccountabilityTarget, null)
.set(Negative::getRectifyRestrictionDays, null)
.eq(Negative::getId, negativeId));
// 删除涉及人员
blameService.remove(negativeId);
// 删除涉及人员问题类型
problemRelationService.remove(negativeId);
}
public void addSignReturn(ActionDto actionDto, String comments) {
UserAuth user = UserContextHolder.getCurrentUser();
NegativeWork work = workService.getById(actionDto.getWorkId());
NegativeSignReturn signReturn = new NegativeSignReturn()
.setNegativeId(actionDto.getNegativeId())
.setActionKey(actionDto.getActionKey())
.setComments(comments)
.setHandlerDepartId(work.getDepartId())
.setHandlerDepartName(work.getDepartName())
.setHandlerUserName(user.getUserName())
.setHandlerName(user.getNickName())
.setCreateTime(LocalDateTime.now());
signReturnService.save(signReturn);
}
public void doneWork(Integer workId) {
workService.update(new LambdaUpdateWrapper<NegativeWork>()
.set(NegativeWork::getStatus, WorkStatusEnum.done.name())
.set(NegativeWork::getUpdateTime, LocalDateTime.now())
.eq(NegativeWork::getId, workId));
}
public void addWork(String negativeId, String roleCode) {
NegativeWork work = workService.getOne(new LambdaQueryWrapper<NegativeWork>().eq(NegativeWork::getNegativeId, negativeId).eq(NegativeWork::getRoleCode, roleCode));
work.setUpdateTime(LocalDateTime.now())
.setStatus(WorkStatusEnum.todo.name());
workService.updateById(work);
}
}

72
src/main/java/com/biutag/supervision/job/Job.java

@ -0,0 +1,72 @@
package com.biutag.supervision.job;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
import com.biutag.supervision.pojo.entity.Negative;
import com.biutag.supervision.pojo.entity.SupDepart;
import com.biutag.supervision.service.NegativeService;
import com.biutag.supervision.service.SupDepartService;
import com.biutag.supervision.util.TimeUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.List;
@RequiredArgsConstructor
@Component
public class Job {
private final NegativeService negativeService;
private final SupDepartService departService;
// 10分钟
// 更新流程状态
@Scheduled(fixedRate = 600000)
public void updateNegativeProcessingStatus() {
List<Negative> list = negativeService.list(new LambdaQueryWrapper<Negative>().isNull(Negative::getProcessingStatus).isNotNull(Negative::getCheckStatus));
list.forEach(item -> {
negativeService.update(new LambdaUpdateWrapper<Negative>().set(Negative::getProcessingStatus, ProcessingStatusEnum.completed).eq(Negative::getId, item.getId()));
});
}
// 更新办理单位
@Scheduled(fixedRate = 600000)
public void updateHandleDepart() {
List<Negative> list = negativeService.list(new LambdaQueryWrapper<Negative>()
.isNotNull(Negative::getInvolveDepartId)
.isNull(Negative::getHandleThreeDepartId)
.isNull(Negative::getFlowKey));
list.forEach(item -> {
SupDepart depart = departService.getById(item.getInvolveDepartId());
if (depart.getLevel() == 3) {
SupDepart parent = departService.getById(depart.getPid());
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getHandleThreeDepartId, depart.getId())
.set(Negative::getHandleThreeDepartName, depart.getShortName())
.set(Negative::getHandleSecondDepartId, parent.getId())
.set(Negative::getHandleSecondDepartName, parent.getShortName())
.eq(Negative::getId, item.getId()));
}
});
}
// 更新办理超时
@Scheduled(fixedRate = 600000)
public void updateHandleTimeout() {
List<Negative> list = negativeService.list(new LambdaQueryWrapper<Negative>()
.isNotNull(Negative::getCompleteDate)
.isNotNull(Negative::getCrtTime)
.isNull(Negative::getFlowKey));
list.forEach(item -> {
long remainingDuration = TimeUtil.getRemainingDuration(item.getCrtTime(), item.getCompleteDate(), 3 * 24 * 60 * 60L);
if (remainingDuration < 0) {
negativeService.update(new LambdaUpdateWrapper<Negative>()
.set(Negative::getHandleTimeout, -remainingDuration)
.eq(Negative::getId, item.getId()));
}
});
}
}

10
src/main/java/com/biutag/supervision/mapper/BaseAccountMapper.java

@ -0,0 +1,10 @@
package com.biutag.supervision.mapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.BaseAccount;
@DS("slave")
public interface BaseAccountMapper extends BaseMapper<BaseAccount> {
}

10
src/main/java/com/biutag/supervision/mapper/BaseRoleMapper.java

@ -0,0 +1,10 @@
package com.biutag.supervision.mapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.BaseRole;
@DS("slave")
public interface BaseRoleMapper extends BaseMapper<BaseRole> {
}

10
src/main/java/com/biutag/supervision/mapper/BaseRoleUserMapper.java

@ -0,0 +1,10 @@
package com.biutag.supervision.mapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.BaseRoleUser;
@DS("slave")
public interface BaseRoleUserMapper extends BaseMapper<BaseRoleUser> {
}

10
src/main/java/com/biutag/supervision/mapper/BaseUserMapper.java

@ -0,0 +1,10 @@
package com.biutag.supervision.mapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.BaseUser;
@DS("slave")
public interface BaseUserMapper extends BaseMapper<BaseUser> {
}

8
src/main/java/com/biutag/supervision/mapper/DataPetitionComplaintMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.DataPetitionComplaint;
public interface DataPetitionComplaintMapper extends BaseMapper<DataPetitionComplaint> {
}

8
src/main/java/com/biutag/supervision/mapper/FlowActionMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.FlowAction;
public interface FlowActionMapper extends BaseMapper<FlowAction> {
}

8
src/main/java/com/biutag/supervision/mapper/FlowNodeMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.FlowNode;
public interface FlowNodeMapper extends BaseMapper<FlowNode> {
}

8
src/main/java/com/biutag/supervision/mapper/HolidayMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.Holiday;
public interface HolidayMapper extends BaseMapper<Holiday> {
}

10
src/main/java/com/biutag/supervision/mapper/MenuMapper.java

@ -0,0 +1,10 @@
package com.biutag.supervision.mapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.Menu;
@DS("slave")
public interface MenuMapper extends BaseMapper<Menu> {
}

8
src/main/java/com/biutag/supervision/mapper/ModelClassMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.ModelClass;
public interface ModelClassMapper extends BaseMapper<ModelClass> {
}

8
src/main/java/com/biutag/supervision/mapper/ModelMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.Model;
public interface ModelMapper extends BaseMapper<Model> {
}

8
src/main/java/com/biutag/supervision/mapper/NegDepartAuthorityMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.NegDepartAuthority;
public interface NegDepartAuthorityMapper extends BaseMapper<NegDepartAuthority> {
}

8
src/main/java/com/biutag/supervision/mapper/NegSourceAuthorityMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.NegSourceAuthority;
public interface NegSourceAuthorityMapper extends BaseMapper<NegSourceAuthority> {
}

8
src/main/java/com/biutag/supervision/mapper/NegativeApproveMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.NegativeApprove;
public interface NegativeApproveMapper extends BaseMapper<NegativeApprove> {
}

8
src/main/java/com/biutag/supervision/mapper/NegativeBlameMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.NegativeBlame;
public interface NegativeBlameMapper extends BaseMapper<NegativeBlame> {
}

8
src/main/java/com/biutag/supervision/mapper/NegativeExtensionApplyMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.NegativeExtensionApply;
public interface NegativeExtensionApplyMapper extends BaseMapper<NegativeExtensionApply> {
}

8
src/main/java/com/biutag/supervision/mapper/NegativeExtensionApproveMapper.java

@ -0,0 +1,8 @@
package com.biutag.supervision.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.biutag.supervision.pojo.entity.NegativeExtensionApprove;
public interface NegativeExtensionApproveMapper extends BaseMapper<NegativeExtensionApprove> {
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save