2025/3/15珀金斯wms后端

.gitignore

@@ -0,0 +1,36 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+/log
+
+### 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/
+.log
+
+### VS Code ###
+.vscode/
+log

mvnw

@@ -0,0 +1,316 @@
+#!/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.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Maven Start Up Batch script
+#
+# Required ENV vars:
+# ------------------
+#   JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+#   M2_HOME - location of maven2's installed home dir
+#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
+#     e.g. to debug Maven itself, use
+#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ] ; then
+
+  if [ -f /usr/local/etc/mavenrc ] ; then
+    . /usr/local/etc/mavenrc
+  fi
+
+  if [ -f /etc/mavenrc ] ; then
+    . /etc/mavenrc
+  fi
+
+  if [ -f "$HOME/.mavenrc" ] ; then
+    . "$HOME/.mavenrc"
+  fi
+
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false
+case "`uname`" in
+  CYGWIN*) cygwin=true ;;
+  MINGW*) mingw=true;;
+  Darwin*) darwin=true
+    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+    if [ -z "$JAVA_HOME" ]; then
+      if [ -x "/usr/libexec/java_home" ]; then
+        export JAVA_HOME="`/usr/libexec/java_home`"
+      else
+        export JAVA_HOME="/Library/Java/Home"
+      fi
+    fi
+    ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+  if [ -r /etc/gentoo-release ] ; then
+    JAVA_HOME=`java-config --jre-home`
+  fi
+fi
+
+if [ -z "$M2_HOME" ] ; then
+  ## resolve links - $0 may be a link to maven's home
+  PRG="$0"
+
+  # need this for relative symlinks
+  while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+      PRG="$link"
+    else
+      PRG="`dirname "$PRG"`/$link"
+    fi
+  done
+
+  saveddir=`pwd`
+
+  M2_HOME=`dirname "$PRG"`/..
+
+  # make it fully qualified
+  M2_HOME=`cd "$M2_HOME" && pwd`
+
+  cd "$saveddir"
+  # echo Using m2 at $M2_HOME
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --unix "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME="`(cd "$M2_HOME"; pwd)`"
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="`which javac`"
+  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=`which readlink`
+    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+      if $darwin ; then
+        javaHome="`dirname \"$javaExecutable\"`"
+        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+      else
+        javaExecutable="`readlink -f \"$javaExecutable\"`"
+      fi
+      javaHome="`dirname \"$javaExecutable\"`"
+      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+  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"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="`\\unset -f command; \\command -v java`"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly." >&2
+  echo "  We cannot execute $JAVACMD" >&2
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+  echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+
+  if [ -z "$1" ]
+  then
+    echo "Path not specified to find_maven_basedir"
+    return 1
+  fi
+
+  basedir="$1"
+  wdir="$1"
+  while [ "$wdir" != '/' ] ; do
+    if [ -d "$wdir"/.mvn ] ; then
+      basedir=$wdir
+      break
+    fi
+    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+    if [ -d "${wdir}" ]; then
+      wdir=`cd "$wdir/.."; pwd`
+    fi
+    # end of workaround
+  done
+  echo "${basedir}"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+  if [ -f "$1" ]; then
+    echo "$(tr -s '\n' ' ' < "$1")"
+  fi
+}
+
+BASE_DIR=`find_maven_basedir "$(pwd)"`
+if [ -z "$BASE_DIR" ]; then
+  exit 1;
+fi
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Found .mvn/wrapper/maven-wrapper.jar"
+    fi
+else
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
+    fi
+    if [ -n "$MVNW_REPOURL" ]; then
+      jarUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    else
+      jarUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    fi
+    while IFS="=" read key value; do
+      case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
+      esac
+    done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Downloading from: $jarUrl"
+    fi
+    wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
+    if $cygwin; then
+      wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
+    fi
+
+    if command -v wget > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found wget ... using wget"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            wget "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        else
+            wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        fi
+    elif command -v curl > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found curl ... using curl"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            curl -o "$wrapperJarPath" "$jarUrl" -f
+        else
+            curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
+        fi
+
+    else
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Falling back to using Java to download"
+        fi
+        javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
+        # For Cygwin, switch paths to Windows format before running javac
+        if $cygwin; then
+          javaClass=`cygpath --path --windows "$javaClass"`
+        fi
+        if [ -e "$javaClass" ]; then
+            if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Compiling MavenWrapperDownloader.java ..."
+                fi
+                # Compiling the Java class
+                ("$JAVA_HOME/bin/javac" "$javaClass")
+            fi
+            if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                # Running the downloader
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Running MavenWrapperDownloader.java ..."
+                fi
+                ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
+            fi
+        fi
+    fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+if [ "$MVNW_VERBOSE" = true ]; then
+  echo $MAVEN_PROJECTBASEDIR
+fi
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --path --windows "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+    MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+exec "$JAVACMD" \
+  $MAVEN_OPTS \
+  $MAVEN_DEBUG_OPTS \
+  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+  "-Dmaven.home=${M2_HOME}" \
+  "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"

mvnw.cmd

@@ -0,0 +1,188 @@
+@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 Maven Start Up Batch script
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM M2_HOME - location of maven2's installed home dir
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Found %WRAPPER_JAR%
+    )
+) else (
+    if not "%MVNW_REPOURL%" == "" (
+        SET DOWNLOAD_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    )
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Couldn't find %WRAPPER_JAR%, downloading it ...
+        echo Downloading from: %DOWNLOAD_URL%
+    )
+
+    powershell -Command "&{"^
+		"$webclient = new-object System.Net.WebClient;"^
+		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+		"}"^
+		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^
+		"}"
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Finished downloading %WRAPPER_JAR%
+    )
+)
+@REM End of extension
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+  %JVM_CONFIG_MAVEN_PROPS% ^
+  %MAVEN_OPTS% ^
+  %MAVEN_DEBUG_OPTS% ^
+  -classpath %WRAPPER_JAR% ^
+  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%

pom.xml

@@ -0,0 +1,190 @@
+<?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.0.2</version>
+        <relativePath/> <!-- lookup parent from repository 3.0.2-->
+    </parent>
+    <groupId>com</groupId>
+    <artifactId>WMS</artifactId>
+    <version>1.0</version>
+    <name>WMS</name>
+    <description>WMS</description>
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+            <version>3.0.0</version>
+        </dependency>
+
+
+
+        <!--        <dependency>-->
+<!--            <groupId>com.mysql</groupId>-->
+<!--            <artifactId>mysql-connector-j</artifactId>-->
+<!--            <scope>runtime</scope>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>com.microsoft.sqlserver</groupId>
+            <artifactId>mssql-jdbc</artifactId>
+            <version>11.2.0.jre17</version> <!-- 适用于 Java 17 -->
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>com.baomidou</groupId>-->
+<!--            <artifactId>mybatis-plus-spring-boot3-starter</artifactId>-->
+<!--            <version>3.5.6</version>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>com.baomidou</groupId>-->
+<!--            <artifactId>dynamic-datasource-spring-boot3-starter</artifactId>-->
+<!--            <version>4.3.0</version>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>com.baomidou</groupId>-->
+<!--            <artifactId>mybatis-plus-boot-starter-test</artifactId>-->
+<!--            <version>3.5.6</version>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- 自定义验证注解 -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <!--常用工具类 -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+
+        <!-- JSON工具类 -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>2.0.21</version>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.13</version>
+        </dependency>
+
+        <!-- MAP工具       -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>31.1-jre</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.github.pagehelper</groupId>
+            <artifactId>pagehelper</artifactId>
+            <version>5.3.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jsqlparser</groupId>
+            <artifactId>jsqlparser</artifactId>
+            <version>4.4</version>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpmime</artifactId>
+            <version>4.5.14</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+            <version>5.2.3</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi</artifactId>
+            <version>5.2.3</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.25</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.oltu.oauth2/org.apache.oltu.oauth2.client -->
+        <dependency>
+            <groupId>org.apache.oltu.oauth2</groupId>
+            <artifactId>org.apache.oltu.oauth2.client</artifactId>
+            <version>1.0.1</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/com.auth0/java-jwt -->
+        <dependency>
+            <groupId>com.auth0</groupId>
+            <artifactId>java-jwt</artifactId>
+            <version>4.4.0</version>
+        </dependency>
+        <!--Swagger-->
+        <dependency>
+            <groupId>io.springfox</groupId>
+            <artifactId>springfox-swagger2</artifactId>
+            <version>2.9.2</version>
+        </dependency>
+        <dependency>
+            <groupId>io.springfox</groupId>
+            <artifactId>springfox-swagger-ui</artifactId>
+            <version>2.9.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.tomcat.embed</groupId>
+            <artifactId>tomcat-embed-core</artifactId>
+            <version>10.1.25</version>
+        </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>easyexcel</artifactId>
+            <version>4.0.1</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>16</source>
+                    <target>16</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

src/main/java/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: com.wuxiShenNan_W8.WmsTestversionApplication
+

src/main/java/com/wms/WmsApplication.java

@@ -0,0 +1,24 @@
+package com.wms;
+
+import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+@SpringBootApplication
+@EnableScheduling
+@EnableTransactionManagement
+@MapperScan("com.wms.mapper")
+public class WmsApplication {
+
+    /**
+     * 主函数，程序的入口
+     *
+     * @param args 命令行参数，以字符串数组形式传入
+     */
+    public static void main(String[] args) {
+        SpringApplication.run(WmsApplication.class, args);
+    }
+
+}

src/main/java/com/wms/bussiness/JobComponent.java

@@ -0,0 +1,544 @@
+package com.wms.bussiness;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.wms.constants.enums.*;
+import com.wms.controller.BaseController;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.container.ContainerApiLocalResponse;
+import com.wms.entity.app.container.CreateInstoreTaskRequest;
+import com.wms.entity.app.container.SendContainerTaskRequest;
+import com.wms.entity.app.wcs.WcsTask;
+import com.wms.entity.table.*;
+import com.wms.mapper.LocationMapper;
+import com.wms.mapper.StockMapper;
+import com.wms.mapper.TaskMapper;
+import com.wms.service.*;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.StringUtils;
+import com.wms.utils.storage.LocationUtils;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+
+/**
+ * 定期任务类
+ */
+@Component
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class JobComponent extends BaseController {
+    /**
+     * 任务服务
+     */
+    private final TaskService taskService;
+
+    /**
+     * 任务 Mapper
+     */
+    private final TaskMapper taskMapper;
+
+    /**
+     * 载具/料箱 服务
+     */
+    private final VehicleService vehicleService;
+    /**
+     * 库位服务
+     */
+    private final LocationService locationService;
+
+    /**
+     * 库位 Mapper
+     */
+    private final LocationMapper locationMapper;
+
+    /**
+     * 库位操作类
+     */
+    private final LocationUtils locationUtils;
+
+    /**
+     * 站台服务
+     */
+    private final StandService standService;
+    /**
+     * 配置服务
+     */
+    private final ConfigService configService;
+    /**
+     * 库存服务
+     */
+    private final StockService stockService;
+    private final TaskRecordService taskRecordService;
+    private final StockMapper stockMapper;
+
+
+    //
+    //@Scheduled(fixedDelay = 1000)
+    public void sendTasksToWcs() {
+        try {
+            // 查找待下发的任务
+            Task taskForQuery = new Task();
+            taskForQuery.setTaskStatus(WmsTaskStatus.NEW.getCode());
+            List<Task> tasks = taskService.selTasks(taskForQuery);
+            if(tasks == null) {
+                logger.error("定时器下发任务发生异常，数据库查询任务列表失败");
+                return;
+            }
+            for(Task task : tasks){
+                if(task.getTaskType().equals(TaskType.IN.getCode())) {
+                    sendTasksInToWcs(task);
+                    return;
+                }
+                if(task.getTaskType().equals(TaskType.OUT.getCode()) || task.getTaskType().equals(TaskType.INVENTORY.getCode())){
+                    sendTasksOutToWcs(task);
+                    return;
+                }
+                if(task.getTaskType().equals(TaskType.MOVE.getCode())){
+                    sendTasksMoveToWcs(task);
+                    return;
+                }
+            }
+        }catch (Exception exception){
+            logger.error("定时器下发任务发生异常：{}", exception.toString());
+        }
+    }
+
+    /**
+     * 发送入库任务给WCS
+     * @param task 任务
+     */
+    private void sendTasksInToWcs(Task task) {
+        try {
+            List<Location> thisLocations = locationService.selLocations(new Location(task.getDestination()));
+            if(thisLocations == null) {
+                logger.warn("下发入库任务查询库位详细信息失败，数据库网络连接异常，任务号：{}", task.getTaskId());
+                return;
+            }
+            if(thisLocations.isEmpty()) {
+                logger.warn("下发入库任务查询库位详细信息异常，不存在详细信息，该库位可能不存在，任务号：{}", task.getTaskId());
+                Task taskForUpdate = new Task();
+                taskForUpdate.setTaskId(task.getTaskId());
+                taskForUpdate.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());
+                taskForUpdate.setRemark1("该库位不存在");
+                taskService.executeTask(taskForUpdate);
+                return;
+            }
+            List<WcsTask> request = new ArrayList<>();
+            // 创建发送的任务
+            WcsTask tempTask = new WcsTask();
+            tempTask.setTaskId(task.getTaskId());
+            tempTask.setTaskType(TaskType.IN.getCode());
+            tempTask.setOrigin(task.getOrigin());
+            tempTask.setDestination(task.getDestination());
+            tempTask.setVehicleNo(task.getVehicleNo());
+            tempTask.setVehicleSize(1);
+            tempTask.setWeight(task.getWeight() == null ? 0 : task.getWeight());
+            tempTask.setPriority(task.getTaskPriority());
+            request.add(tempTask);
+            // 发送任务
+            ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_SEND_TASK.getValue(), JSON.toJSONString(request)), ResponseEntity.class);
+            if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
+                logger.info("下发立库入库任务成功，任务ID：{}，任务信息：{}", tempTask.getTaskId(), JSON.toJSONString(request));
+                Task taskForUpdate = new Task();
+                taskForUpdate.setTaskId(task.getTaskId());
+                taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
+                taskService.executeTask(taskForUpdate);
+                return;
+            }
+            logger.info("下发立库入库任务失败，任务ID：{}，信息：{}", tempTask.getTaskId(), JSON.toJSONString(result));
+        }catch (Exception exception){
+            logger.error("下发入库任务发生异常：{}", exception.toString());
+        }
+    }
+
+    /**
+     * 发送出库任务给WCS
+     * @param task 任务
+     */
+    private void sendTasksOutToWcs(Task task) {
+        /* 检查该库位前一个深度是否存在库存，若存在库存则生成一个移库任务，此任务暂不下发 */
+        List<Location> thisLocations = locationService.selLocations(new Location(task.getOrigin()));
+        if(thisLocations == null) {
+            logger.warn("下发出库任务查询库位详细信息失败，数据库网络连接异常，库位号：{}", task.getOrigin());
+            return;
+        }
+        if(thisLocations.isEmpty()) {
+            logger.warn("下发出库任务查询库位详细信息异常，不存在详细信息，该库位可能不存在，任务号：{}", task.getTaskId());
+            Task taskForUpdate = new Task();
+            taskForUpdate.setTaskId(task.getTaskId());
+            taskForUpdate.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());
+            taskForUpdate.setRemark1("该库位不存在");
+            taskService.executeTask(taskForUpdate);
+            return;
+        }
+        Location thisLocation = thisLocations.get(0); // 找出当前库位详细信息
+        int depth = thisLocation.getDepth();
+        while (depth > 1) {
+            depth--;
+            /* 检查该库位有没有任务，若有则退出函数，若没有则检查有没有库存，若没有库存则继续，若有库存则生成一个移库任务，生成之后退出函数 */
+            Location beforLocationsQuery = new Location();
+            beforLocationsQuery.setAreaId(thisLocation.getAreaId());
+            beforLocationsQuery.setQueue(thisLocation.getQueue());
+            beforLocationsQuery.setLine(thisLocation.getLine());
+            beforLocationsQuery.setLayer(thisLocation.getLayer());
+            beforLocationsQuery.setDepth(depth);
+            //需要检查三巷道，如果是小托盘需要倒序，大托盘就正序
+            List<Location> beforLocations =locationService.selDescLocations(beforLocationsQuery);
+            if(thisLocation.getTunnelId() == 3){
+                //终点104的是大托盘，241的是小托盘
+                if (Objects.equals(task.getDestination(), "104")){
+                    beforLocations = locationService.selLocations(beforLocationsQuery);
+                }
+            }
+            //List<Location> beforLocations = beforLocationsForWrite;
+            if(beforLocations == null) {
+                logger.warn("下发出库任务查询库位详细信息失败，数据库网络连接异常，任务号：{}", task.getTaskId());
+                return;
+            }
+            if(beforLocations.isEmpty()) {
+                return;
+            }
+            Location beforLocation = beforLocations.get(0); // 前一个库位
+            List<Task> notCompleteTasks = taskMapper.haveNotCompleteTask(beforLocation.getLocationId());
+            if(notCompleteTasks == null) {
+                return;
+            }
+            if(!notCompleteTasks.isEmpty()) {
+                return; // 存在未完成的任务，退出函数
+            }
+            // 检查前一个位置是否有库存
+            Stock stockQuery = new Stock();
+            stockQuery.setLocationId(beforLocation.getLocationId());
+            List<Stock> stocks = stockService.selStocks(stockQuery);
+            if(stocks == null) {
+                return;
+            }
+            if(stocks.isEmpty()) {
+                continue; // 没有库存，继续
+            }
+            /* 生成一个移库任务 */
+            /* 查找一个空库位 */
+            Location emptyLocation = new Location();
+            emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+            emptyLocation.setAreaId(beforLocation.getAreaId());
+            //需要判断，大小托盘查找库位需要做区分
+            List<Location> emptyLocations;
+            if (beforLocation.getTunnelId() == 3){
+                 emptyLocations = locationMapper.selLocationsByDesc(emptyLocation);
+            }else {
+                 emptyLocations = locationMapper.selLocations(emptyLocation);
+            }
+
+            if(emptyLocations == null) {
+                return;
+            }
+            if(emptyLocations.isEmpty()){
+                return; // 移库没有可用库位
+            }
+            Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations); // 取得新库位
+            if(emptyLocationItem == null) {
+                return; // 没有可用库位或者m库位存在干涉
+            }
+            // 锁定旧库位库存
+            stockMapper.updateStockStatusWithLocationId(beforLocation.getLocationId(), StockStatus.LOCK.getCode());
+            // 锁定新库位
+            Location locationForUpdate = new Location();
+            locationForUpdate.setLocationId(emptyLocationItem.getLocationId());
+            locationForUpdate.setLocationStatus(LocationStatus.OCCUPY.getCode());
+            locationMapper.modifyLocation(locationForUpdate);
+            // 构造移库任务
+            Task moveTask = new Task();
+            moveTask.setTaskId(UUID.randomUUID().toString());
+            moveTask.setTaskGroup(task.getTaskGroup());
+            moveTask.setTaskType(TaskType.MOVE.getCode());
+            moveTask.setOrigin(beforLocation.getLocationId());
+            moveTask.setDestination(emptyLocationItem.getLocationId());
+            moveTask.setVehicleNo(stocks.get(0).getVehicleId());
+            moveTask.setVehicleSize(0);
+            moveTask.setWeight(0.0);
+            moveTask.setTaskPriority(9);
+            moveTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
+            taskService.addTask(moveTask);
+            return;
+        }
+        // 宝开立库
+            List<WcsTask> request = new ArrayList<>();
+            // 创建发送的任务
+            WcsTask tempTask = new WcsTask();
+            tempTask.setTaskId(task.getTaskId());
+            tempTask.setTaskType(task.getTaskType());
+            tempTask.setOrigin(task.getOrigin());
+            tempTask.setDestination(task.getDestination());
+            tempTask.setVehicleNo(task.getVehicleNo());
+            tempTask.setVehicleSize(1);
+            tempTask.setWeight(task.getWeight() == null ? 0 : task.getWeight());
+            tempTask.setPriority(task.getTaskPriority());
+            request.add(tempTask);
+            // 发送任务
+            ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_SEND_TASK.getValue(), JSON.toJSONString(request)), ResponseEntity.class);
+            if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
+                logger.info("下发立库出库任务成功，任务ID：{}", tempTask.getTaskId());
+                Task taskForUpdate = new Task();
+                taskForUpdate.setTaskId(task.getTaskId());
+                taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
+                taskService.executeTask(taskForUpdate);
+                return;
+            }
+        if (result != null) {
+            logger.info("下发立库出库任务失败，任务ID：{}，信息：{}，result结果：{}", tempTask.getTaskId(), JSON.toJSONString(result),result.getCode());
+        }
+
+    }
+
+    /**
+     * 发送移库任务给WCS
+     * @param task 任务
+     */
+    private void sendTasksMoveToWcs(Task task) {
+        /* 检查该库位前一个深度是否存在库存，若存在库存则生成一个移库任务，此任务暂不下发 */
+        List<Location> thisLocations = locationService.selLocations(new Location(task.getOrigin()));
+        if(thisLocations == null) {
+            logger.warn("下发移库任务查询库位详细信息失败，数据库网络连接异常，任务号：{}", task.getTaskId());
+            return;
+        }
+        if(thisLocations.isEmpty()) {
+            logger.warn("下发移库任务查询库位详细信息异常，不存在详细信息，该库位可能不存在，任务号：{}", task.getTaskId());
+            Task taskForUpdate = new Task();
+            taskForUpdate.setTaskId(task.getTaskId());
+            taskForUpdate.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());
+            taskForUpdate.setRemark1("该库位不存在");
+            taskService.executeTask(taskForUpdate);
+            return;
+        }
+        Location thisLocation = thisLocations.get(0); // 找出当前库位详细信息
+        int depth = thisLocation.getDepth();
+        while (depth > 1) {
+            depth--;
+            /* 检查该库位有没有任务，若有则退出函数，若没有则检查有没有库存，若没有库存则继续，若有库存则生成一个移库任务，生成之后退出函数 */
+            Location beforLocationsQuery = new Location();
+            beforLocationsQuery.setAreaId(thisLocation.getAreaId());
+            beforLocationsQuery.setQueue(thisLocation.getQueue());
+            beforLocationsQuery.setLine(thisLocation.getLine());
+            beforLocationsQuery.setLayer(thisLocation.getLayer());
+            beforLocationsQuery.setDepth(depth);
+            List<Location> beforLocations = locationService.selLocations(beforLocationsQuery);
+            if(beforLocations == null) {
+                logger.warn("下发移库任务查询库位详细信息失败，数据库网络连接异常，任务号：{}", task.getTaskId());
+                return;
+            }
+            if(beforLocations.isEmpty()) {
+                return;
+            }
+            Location beforLocation = beforLocations.get(0); // 前一个库位
+            List<Task> notCompleteTasks = taskMapper.haveNotCompleteTask(beforLocation.getLocationId());
+            if(notCompleteTasks == null) {
+                return;
+            }
+            for(Task notCompleteTask : notCompleteTasks) {
+                String taskId = notCompleteTask.getTaskId();
+                if(!taskId.equals(task.getTaskId())) {
+                    return;
+                }
+            }
+            // 检查是否有库存、
+            Stock stockQuery = new Stock();
+            stockQuery.setLocationId(beforLocation.getLocationId());
+            List<Stock> stocks = stockService.selStocks(stockQuery);
+            if(stocks == null) {
+                return;
+            }
+            if(stocks.isEmpty()) {
+                continue; // 没有库存，继续
+            }
+            /* 生成一个移库任务 */
+            /* 查找一个空库位 */
+            Location emptyLocation = new Location();
+            emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+            emptyLocation.setAreaId(beforLocation.getAreaId());
+            List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
+            if(emptyLocations == null) {
+                return;
+            }
+            if(emptyLocations.isEmpty()){
+                return; // 移库没有可用库位
+            }
+            Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations); // 取得新库位
+            if(emptyLocationItem == null) {
+                return; // 没有可用库位或者m库位存在干涉
+            }
+            // 锁定旧库位库存
+            stockMapper.updateStockStatusWithLocationId(beforLocation.getLocationId(), StockStatus.LOCK.getCode());
+            // 锁定新库位
+            Location locationForUpdate = new Location();
+            locationForUpdate.setLocationId(emptyLocationItem.getLocationId());
+            locationForUpdate.setLocationStatus(LocationStatus.OCCUPY.getCode());
+            locationMapper.modifyLocation(locationForUpdate);
+            // 构造移库任务
+            Task moveTask = new Task();
+            moveTask.setTaskId(UUID.randomUUID().toString());
+            moveTask.setTaskGroup(task.getTaskGroup());
+            moveTask.setTaskType(TaskType.MOVE.getCode());
+            moveTask.setOrigin(beforLocation.getLocationId());
+            moveTask.setDestination(emptyLocationItem.getLocationId());
+            moveTask.setVehicleNo(stocks.get(0).getVehicleId());
+            moveTask.setVehicleSize(0);
+            moveTask.setWeight(0.0);
+            moveTask.setTaskPriority(9);
+            moveTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
+            taskService.addTask(moveTask);
+            return;
+        }
+        if(thisLocation.getAreaId() == 1) { // 宝开立库
+            List<WcsTask> request = new ArrayList<>();
+            // 创建发送的任务
+            WcsTask tempTask = new WcsTask();
+            tempTask.setTaskId(task.getTaskId());
+            tempTask.setTaskType(TaskType.MOVE.getCode());
+            tempTask.setOrigin(task.getOrigin());
+            tempTask.setDestination(task.getDestination());
+            tempTask.setVehicleNo(task.getVehicleNo());
+            tempTask.setVehicleSize(1);
+            tempTask.setWeight(task.getWeight() == null ? 0 : task.getWeight());
+            tempTask.setPriority(task.getTaskPriority());
+            request.add(tempTask);
+            // 发送任务
+            ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_SEND_TASK.getValue(), JSON.toJSONString(request)), ResponseEntity.class);
+            if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
+                logger.info("下发立库移库任务成功，任务ID：{}", tempTask.getTaskId());
+                Task taskForUpdate = new Task();
+                taskForUpdate.setTaskId(task.getTaskId());
+                taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
+                taskService.executeTask(taskForUpdate);
+                return;
+            }
+            logger.info("下发立库移库任务失败，任务ID：{}，信息：{}", tempTask.getTaskId(), JSON.toJSONString(result));
+        }
+    }
+
+
+
+
+    /**
+     * 每隔一秒检索一遍任务列表，同时向WCS下发任务
+     */
+//    @Scheduled(fixedDelay = 1000)
+    public void executeTasks() {
+        try {
+            // 检索任务列表，查询状态为等待状态的任务
+            Task taskForQuery = new Task();
+            taskForQuery.setTaskStatus(WmsTaskStatus.NEW.getCode());
+            List<Task> tasks = taskService.selTasks(taskForQuery);
+            // 相同任务组的任务只发一次
+            List<String> taskGroupIds = new LinkedList<>();
+            List<WcsTask> request = new ArrayList<>();
+            if (!tasks.isEmpty()) {// 存在等待中的任务
+                for (Task task : tasks) {
+                    if (taskGroupIds.contains(task.getTaskGroup())) {// 该taskGroup的任务已经发送过
+                        task.setTaskStatus(WmsTaskStatus.WAIT.getCode());
+                        continue;
+                    }
+                    // 创建发送的任务
+                    WcsTask tempTask = new WcsTask();
+                    tempTask.setTaskId(task.getTaskGroup());
+                    if (TaskType.OUT.getCode().equals(task.getTaskType()) || TaskType.INVENTORY.getCode().equals(task.getTaskType())) {
+                        tempTask.setTaskType(TaskType.OUT.getCode());
+                    } else {
+                        tempTask.setTaskType(TaskType.IN.getCode());
+                    }
+                    tempTask.setOrigin(task.getOrigin());
+                    tempTask.setDestination(task.getDestination());
+                    tempTask.setVehicleNo(task.getVehicleNo());
+                    tempTask.setVehicleSize(1);
+                    tempTask.setWeight(task.getWeight() == null ? 0 : task.getWeight());
+                    tempTask.setPriority(task.getTaskPriority());
+                    request.add(tempTask);
+
+                    taskGroupIds.add(task.getTaskGroup());
+                    task.setTaskStatus(WmsTaskStatus.WAIT.getCode());
+                }
+                if (request.isEmpty()) {
+                    return;
+                }
+                // 发送任务
+                ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_SEND_TASK.getValue(), JSON.toJSONString(request)), ResponseEntity.class);
+                if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
+                    // 更新任务列表
+                    for (Task task : tasks) {
+                        // 更新任务
+                        taskService.executeTask(task);
+                    }
+                }
+            }
+        } catch (Exception exception) {
+            logger.error("发生异常：{}", exception.getMessage());
+        }
+    }
+
+    /**
+     * 定期检查设备状态
+     * 5秒钟
+     */
+//    @Scheduled(fixedDelay = 5000)
+    public void checkEquipmentStatus() {
+
+    }
+
+    /**
+     * 每天查询一次是否有过期的库存
+     * 每天晚上8点执行一次
+     */
+//    @Scheduled(cron = "0 0 20 * * ?")
+    public void detectOutOfDateStock() {
+        logger.info("执行定时任务：查询过期库存");
+        List<Stock>  outOfDateStocks = stockService.selStockOutOfDate();
+        if (!outOfDateStocks.isEmpty()) {
+            logger.info("过期库存数量不为0，准备更新过期库存");
+            for (Stock outOfDateStock : outOfDateStocks) {
+                try {
+                    outOfDateStock.setGoodsStatus(GoodsStatus.OVERDUE.getCode());
+                    stockService.modifyStock(outOfDateStock);
+                    logger.info("过期库存更新成功");
+                } catch (Exception e) {
+                    logger.error("过期库存更新异常：{}", e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * 每天查询一次是否有入库后长期未使用的库存
+     * 每天晚上9点执行一次
+     */
+//    @Scheduled(cron = "0 0 21 * * ?")
+    public void detectStockLongTimeNoUse() {
+        logger.info("执行定时任务：查询是否有入库后长期未使用的库存");
+        List<Stock>  stocksLongTimeNoUse = stockService.selStockLongTimeNoUse(7);
+        if (!stocksLongTimeNoUse.isEmpty()) {
+            logger.info("有入库后长期未使用的库存, 准备更新库存状态");
+            for (Stock stockLongTimeNoUse : stocksLongTimeNoUse) {
+                try {
+                    stockLongTimeNoUse.setGoodsStatus(GoodsStatus.SCRAP.getCode());
+                    stockService.modifyStock(stockLongTimeNoUse);
+                    logger.info("长时间未使用库存状态更新成功");
+                } catch (Exception e) {
+                    logger.error("长时间未使用库存状态更新异常：{}", e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * 每天查询一次是否有过期记录
+     * 每天晚上10点执行一次
+     */
+    //@Scheduled(cron = "0 0 22 * * ?")
+    public void deleteOutOfDateData() {
+        logger.info("执行定时任务：删除过期数据");
+        taskRecordService.deleteTaskRecordRegularly();
+    }
+
+
+}

src/main/java/com/wms/bussiness/TaskOperation.java

@@ -0,0 +1,791 @@
+package com.wms.bussiness;
+
+import com.alibaba.fastjson2.JSON;
+import com.wms.constants.enums.*;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.mes.*;
+import com.wms.entity.app.wcs.WmsReceiveTaskResultEntity;
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.table.*;
+import com.wms.mapper.*;
+import com.wms.service.PartInfoService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.WmsUtils;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.poi.ss.formula.functions.Now;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import javax.swing.plaf.synth.Region;
+import java.math.BigDecimal;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.*;
+
+
+/**
+ * 对任务的操作
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class TaskOperation {
+
+    /**
+     * 库存 Mapper
+     */
+    private final StockMapper stockMapper;
+
+    /**
+     * 任务表操作类
+     */
+    private final TaskMapper taskMapper;
+
+    /**
+     * 库位表操作类
+     */
+    private final LocationMapper locationMapper;
+
+    /**
+     * 零件
+     */
+    private final PartInfoService partInfoService;
+    private final OrderOutMapper orderOutMapper;
+    private final TaskRecordMapper taskRecordMapper;
+    private final VehicleMapper vehicleMapper;
+    private final OledInMapper oledInMapper;
+    /**
+     * 订单入库
+     */
+    private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
+
+
+    //region 完成任务
+    /**
+     * 完成任务
+     * @param task 要完成的任务
+     * @return 操作结果
+     */
+    public boolean completeTask(Task task) {
+        if(task == null) {
+            return false;
+        }
+        TaskType taskType = TaskType.getTaskType(task.getTaskType());
+        if(taskType == null) {
+            return false;
+        }
+        /* 根据任务类型判断 */
+        return switch (taskType) {
+            case IN -> completeInTask(task);
+            case OUT -> completeOutTask(task);
+            case INVENTORY -> completeInventoryTask(task);
+            case MOVE -> completeMoveTask(task);
+        };
+    }
+
+    /**
+     * 完成入库任务
+     * @param task 要完成的入库任务
+     * @return 结果
+     */
+    private boolean completeInTask(Task task) {
+        /* 找出任务，完成该任务；找出该任务终点，更新库存为OK */
+        // 完成任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 完成任务
+        //占掉新库位，生成的时候会占，这里重复操作保护
+        Location occupyLocation = new Location();
+        occupyLocation.setLocationId(task.getDestination());
+        occupyLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+        occupyLocation.setVehicleId(task.getVehicleNo());
+        locationMapper.modifyLocation(occupyLocation); // 更新库位
+        //判断是否为空托入库，是的话就写入载具表，不写入库存表
+        if (Objects.equals(task.getRemark1(), "空托垛入库")){
+            Vehicle vehicleForUse = new Vehicle();
+            vehicleForUse.setVehicleStatus(0);
+            vehicleForUse.setCurrentLocation(task.getDestination());
+            if (Objects.equals(task.getPickStand(), "大")){
+                vehicleForUse.setIsEmpty(1);
+            }else{
+                vehicleForUse.setIsEmpty(0);
+            }
+            //1代表是大托盘，0代表是小托盘
+            vehicleForUse.setVehicleId(task.getVehicleNo());
+            int a = vehicleMapper.addVehicle(vehicleForUse);
+            if (a > 0){
+                log.info("空托入库更新载具表成功！");
+            }else {log.info("空托入库更新载具表失败！");}
+            //写进库存
+            Stock addStock = new Stock();
+            addStock.setStockId(WmsUtils.generateUUIDString());
+            addStock.setWarehouseName("珀金斯立体库");
+            addStock.setLocationId(task.getDestination());
+            addStock.setVehicleId(task.getVehicleNo());
+            addStock.setGoodsId(task.getGoodsId());//物料号，序列号
+            addStock.setGoodsName(task.getGoodsName());//机型
+            //机型，序列号，物料号，数量，入库日期
+            addStock.setBatchNo("空托垛");
+            addStock.setAvailableNum(task.getOperateNum());//数量
+            addStock.setRealNum(task.getOperateNum());
+            addStock.setProviderId("");
+            addStock.setProviderName(task.getPickStand());//判断大小托盘
+            //addStock.setProductionDate(null);
+            addStock.setExpirationDate(null);
+            addStock.setStockStatus(0);
+            addStock.setGoodsStatus(null);
+            addStock.setCreateTime(new Date());//入库日期
+            addStock.setLastUpdateTime(null);
+            addStock.setLastUpdateUser("");
+            addStock.setRemark(task.getRemark1());
+            addStock.setProductionDate(task.getProductionDate());
+            // 整箱入库直接更新库存
+            int aA = stockMapper.addStock(addStock);
+            if (aA == 0){//表示添加库存失败
+                log.info("空托垛入库完成更新库存失败，任务：{}，原因：添加库存失败", task.toLoggerString());
+                for (int i = 0; i < 5; i++) {
+                    int b =stockMapper.addStock(addStock);
+                    if (b != 0){
+                        log.info("空托垛入库更新库存重试成功，托盘号：{}", task.getVehicleNo());
+                        break;
+                    }
+                }
+            }else {
+                log.info("空托垛入库完成更新库存成功，托盘号：{}", task.getVehicleNo());
+            }
+        } else if (Objects.equals(task.getGoodsId(), "YJRK0001")) {
+            //代表是原材料并箱入库
+            List<AppOrderIn> appOrderInList = appOrderInMapper.selectWithVehicle(task.getVehicleNo());
+            for (AppOrderIn appOrderIn : appOrderInList) {
+                //写进库存
+                Stock stock = new Stock();
+                stock.setStockId(WmsUtils.generateUUIDString());
+                stock.setWarehouseName("珀金斯立体库");
+                stock.setLocationId(task.getDestination());
+                stock.setVehicleId(task.getVehicleNo());
+                stock.setGoodsId(appOrderIn.getGoodsId());//物料号，序列号
+                //stock.setGoodsName(task.getGoodsName());//机型
+                //机型，序列号，物料号，数量，入库日期
+                stock.setBatchNo(task.getUserName());
+                stock.setAvailableNum(appOrderIn.getGoodsNum().intValue());//数量
+                stock.setRealNum(appOrderIn.getGoodsNum().intValue());
+                stock.setProviderId("");
+                stock.setProviderName(task.getPickStand());//判断大小托盘
+                //addStock.setProductionDate(null);
+                stock.setExpirationDate(null);
+                stock.setStockStatus(0);
+                stock.setGoodsStatus(null);
+                stock.setCreateTime(new Date());//入库日期
+                stock.setLastUpdateTime(null);
+                stock.setLastUpdateUser("");
+                stock.setRemark(task.getRemark1());
+                stock.setProductionDate(appOrderIn.getProductionDate());
+                if (stockMapper.addStock(stock) > 0){
+                    log.info("原材料入库更新库存重试成功，托盘号：{}", task.getVehicleNo());
+                }else {
+                    log.info("原材料入库更新库存重试失败，托盘号：{}", task.getVehicleNo());
+                }
+            }
+            //删除入库单
+            if (appOrderInMapper.deleteByVehicleNo(task.getVehicleNo()) > 0){
+                log.info("原材料入库删除入库单成功，托盘号：{}", task.getVehicleNo());
+            }
+        } else if (Objects.equals(task.getOrigin(), "104")) {
+            if(stockMapper.updateStockStatusWithLocationId(task.getDestination(), 0) > 0){
+                log.info("更新库存成功，托盘号：{}", task.getVehicleNo());
+            }
+            log.error("更新库存失败，托盘号：{}", task.getVehicleNo());
+        } else {
+            //写进库存
+            Stock addStock = new Stock();
+            addStock.setStockId(WmsUtils.generateUUIDString());
+            addStock.setWarehouseName("珀金斯立体库");
+            addStock.setLocationId(task.getDestination());
+            addStock.setVehicleId(task.getVehicleNo());
+            addStock.setGoodsId(task.getGoodsId());//物料号，序列号
+            addStock.setGoodsName(task.getGoodsName());//机型
+            //机型，序列号，物料号，数量，入库日期
+            addStock.setBatchNo(task.getUserName());
+            addStock.setAvailableNum(task.getOperateNum());//数量
+            addStock.setRealNum(task.getOperateNum());
+            addStock.setProviderId("");
+            addStock.setProviderName(task.getPickStand());//判断大小托盘
+            //addStock.setProductionDate(null);
+            addStock.setExpirationDate(null);
+            addStock.setStockStatus(0);
+            addStock.setGoodsStatus(null);
+            addStock.setCreateTime(new Date());//入库日期
+            addStock.setLastUpdateTime(null);
+            addStock.setLastUpdateUser("");
+            addStock.setRemark(task.getRemark1());
+            addStock.setProductionDate(task.getProductionDate());
+            // 整箱入库直接更新库存
+            int a = stockMapper.addStock(addStock);
+            if (a == 0){//表示添加库存失败
+                log.info("入库完成更新库存失败，任务：{}，原因：添加库存失败", task.toLoggerString());
+                for (int i = 0; i < 5; i++) {
+                    int b =stockMapper.addStock(addStock);
+                    if (b != 0){
+                        log.info("入库更新库存重试成功，托盘号：{}", task.getVehicleNo());
+                        break;
+                    }
+                }
+            }else {
+                log.info("入库完成更新库存成功，托盘号：{}", task.getVehicleNo());
+            }
+        }
+
+        //开始将入库记录备份进task备份表
+        Task taskRecordBack = new Task();
+        taskRecordBack.setTaskId(task.getTaskId());
+        taskRecordBack.setTaskType(1);
+        taskRecordBack.setGoodsName(task.getGoodsName());
+        taskRecordBack.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        taskRecordBack.setOrigin(task.getOrigin());
+        taskRecordBack.setDestination(task.getDestination());
+        taskRecordBack.setVehicleNo(task.getVehicleNo());
+        taskRecordBack.setCreateTime(task.getCreateTime());
+        taskRecordBack.setGoodsId(task.getGoodsId());
+        taskRecordBack.setOperateNum(task.getOperateNum());
+        taskRecordBack.setFinishTime(new Date());
+        int x = taskRecordMapper.addTask(taskRecordBack);
+        if (x == 0){
+            log.info("入库更新任务备份表失败，任务：{}，", task.toLoggerString());
+            for (int i = 0; i < 5; i++) {
+                int d = taskRecordMapper.addTask(taskRecordBack);
+                if (d != 0){
+                    log.info("入库更新任务备份表重试成功，托盘号：{}", task.getVehicleNo());
+                    break;
+                }
+            }
+        }else {
+            log.info("入库更新任务备份表成功，托盘号：{}", task.getVehicleNo());
+        }
+        //入库完成删除Task表
+        int abx = taskMapper.deleteTask(task.getTaskId());
+        if (abx == 0){
+            log.info("入库删除任务表失败，任务：托盘号：{}", task.getVehicleNo());
+            for (int i = 0; i < 5; i++) {
+                int c = taskMapper.deleteTask(task.getTaskId());
+                if (c != 0){
+                    log.info("入库删除任务表重试成功，托盘号：{}", task.getVehicleNo());
+                    break;
+                }
+            }
+        }else {
+            log.info("入库删除任务表成功");
+        }
+        //入库完成删除oled显示内容
+        if(oledInMapper.deleteByVehicleNo(task.getVehicleNo())>0){
+            log.info("入库删除oled显示内容成功，托盘号：{}", task.getVehicleNo());
+        }else {
+            log.info("入库删除oled显示内容失败，托盘号：{}", task.getVehicleNo());
+        }
+        return true;
+    }
+
+
+    /**
+     * 完成出库任务
+     * @param task 要完成的出库任务
+     * @return 执行结果
+     */
+    private boolean completeOutTask(Task task) {
+        /* 找出任务，完成该任务；找出该任务终点，删除库存；释放库位 */
+        // 完成任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 完成任务
+        // 释放库位
+        Location updateLocation = new Location();
+        updateLocation.setLocationId(task.getOrigin());
+        updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setVehicleId("");
+        locationMapper.modifyLocation(updateLocation); // 更新库位为空
+
+//        // 根据起点拉取库位库存,剩下数量不为零的数据搬运到入库单 生成回库任务，删除该库位所有库存
+//        List<Stock> stocks  = stockMapper.selStocksByLocationId(task.getOrigin());
+//        if (stocks == null || stocks.isEmpty()){
+//            log.error("拉取库存失败，任务：{}，原因：没有找到库存数据", task.toLoggerString());
+//            return false;
+//        }
+//        for (Stock stock : stocks){
+//            if (stock.getAvailableNum() > 0){
+//                AppOrderIn appOrderIn = new AppOrderIn();
+//                appOrderIn.setRowId(WmsUtils.generateUUIDString());
+//                appOrderIn.setGuid(stock.getStockId());
+//                appOrderIn.setInType(1);
+//                appOrderIn.setBatchNo(stock.getBatchNo());
+//                appOrderIn.setVehicleNo(task.getVehicleNo());
+//                appOrderIn.setGoodsId(stock.getGoodsId());
+//                appOrderIn.setGoodsNum(BigDecimal.valueOf(stock.getAvailableNum()));
+//                appOrderIn.setWareHouse(stock.getWarehouseName());
+//                if (stock.getVehicleId() != null && !stock.getVehicleId().isEmpty()){
+//                    appOrderIn.setOrderStatus(2);
+//                }else {
+//                    appOrderIn.setOrderStatus(0);
+//                }
+//                appOrderIn.setCreateTime(LocalDate.now());
+//                appOrderIn.setUpdateTime(LocalDateTime.now());
+//                appOrderIn.setCreatePerson("BACK");
+//                appOrderIn.setRemark("回库");
+//                int isSuessInsert = appOrderInMapper.insert(appOrderIn);
+//                if(isSuessInsert > 0){
+//                    log.info("回库任务生成成功，任务：{}", task.toLoggerString());
+//                }else{
+//                    log.error("回库任务生成失败，任务：{}", task.toLoggerString());
+//                }
+//            }
+//        }
+        //空托出库删除载具表
+        if (Objects.equals(task.getRemark1(), "空托垛出库")){
+            Vehicle vehicle = new Vehicle();
+            vehicle.setCurrentLocation(task.getOrigin());
+            vehicleMapper.deleteVehicleByLocation(vehicle);
+            log.info("空托垛出库删除载具单成功");
+        }
+
+        //开始将chu库记录备份进task备份表
+
+        Task taskRecordBack = new Task();
+        taskRecordBack.setTaskId(task.getTaskId());
+        taskRecordBack.setTaskType(2);
+        taskRecordBack.setGoodsName(task.getGoodsName());
+        taskRecordBack.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        taskRecordBack.setOrigin(task.getOrigin());
+        taskRecordBack.setDestination(task.getDestination());
+        taskRecordBack.setVehicleNo(task.getVehicleNo());
+        taskRecordBack.setCreateTime(task.getCreateTime());
+        taskRecordBack.setGoodsId(task.getGoodsId());
+        taskRecordBack.setOperateNum(task.getOperateNum());
+        taskRecordBack.setFinishTime(new Date());
+        taskRecordBack.setTaskPriority(task.getTaskPriority());
+        int x = taskRecordMapper.addTask(taskRecordBack);
+        if (x == 0){
+            log.info("出库更新任务备份表失败，任务：{}，", task.toLoggerString());
+            for (int i = 0; i < 5; i++) {
+                int d = taskRecordMapper.addTask(taskRecordBack);
+                if (d != 0){
+                    log.info("出库更新任务备份表重试成功，任务：{}", task.toLoggerString());
+                    break;
+                }
+            }
+        }else {
+            log.info("出库更新任务备份表成功，任务：{}", task.toLoggerString());
+        }
+        //删除task表数据
+        int deleteResultForTask = taskMapper.deleteTask(task.getTaskId());
+        if (deleteResultForTask == 0){
+            for (int i = 0; i < 5; i++) {
+                int d = taskMapper.deleteTask(task.getTaskId());
+                if (d != 0){
+                    log.info("出库完成删除Task成功");
+                    break;
+                }
+            }
+            log.info("出库完成删除Task失败，重新");
+        }else {
+            log.info("出库完成删除Task成功，任务：{}", task.toLoggerString());
+        }
+        if(!Objects.equals(task.getRemark1(), "空托垛出库") && !Objects.equals(task.getTaskGroup(), "PYPK")){
+            // 删除手动出库的出库单
+            List<OrderOut> outList = orderOutMapper.queryWithRowId(task.getTaskGroup());
+            if (outList == null || outList.isEmpty()){
+                log.info("出库的出库单不存在，任务：{}", task.toLoggerString());
+                return false;
+            }
+            if (outList.get(0).getOrderType() == 2){
+                orderOutMapper.deleteOrderOut(task.getTaskGroup());
+                log.info("手动出库的出库单删除成功，任务：{}", task.toLoggerString());
+            }else{
+                //更改出库单状态为完成
+                OrderOut orderOutUpdateStatus = new OrderOut();
+                orderOutUpdateStatus.setRowId(task.getTaskGroup());
+                orderOutUpdateStatus.setStatus(OrderOutStatusEnum.FINISHED.getCode());
+                int a = orderOutMapper.update(orderOutUpdateStatus);
+                if (a > 0){
+                    log.info("更新出库单状态成功");
+                }else {
+                    log.info("更新出库单状态失败");
+                }
+            }
+            // 删除当前载具号的所有库存，出库单更新状
+            int updateStock = stockMapper.deleteStockWithLocationId(task.getOrigin());
+            if(updateStock > 0){
+                log.info("出库完成删除库存成功，任务：{}", task.toLoggerString());
+                return true;
+            }
+        }else{
+            // 删除当前载具号的所有库存，出库单更新状
+            int updateStock = stockMapper.deleteStockWithLocationId(task.getOrigin());
+            if(updateStock > 0){
+                log.info("空托出库完成删除库存成功，任务：{}", task.toLoggerString());
+            }else{
+                log.info("空托出库完成删除库存失败，任务：{}", task.toLoggerString());
+            }
+            log.info("空托垛出库完成，任务：{}", task.toLoggerString());
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * 完成盘点任务
+     * @param task 任务
+     * @return 完成结果
+     */
+    private boolean completeInventoryTask(Task task) {
+        /* 找出任务，完成该任务；找出该任务终点，删除库存；释放库位 */
+        // 完成任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 完成任务
+        // 释放库位
+        Location updateLocation = new Location();
+        updateLocation.setLocationId(task.getOrigin());
+        updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setVehicleId("");
+        locationMapper.modifyLocation(updateLocation); // 更新库位为空
+        // 根据起点拉取库位库存,剩下数量不为零的数据搬运到入库单 生成回库任务，删除该库位所有库存
+        List<Stock> stocks  = stockMapper.selStocksByLocationId(task.getOrigin());
+        if (stocks == null || stocks.isEmpty()){
+            log.error("完成盘点出库拉取库存失败，任务：{}，原因：没有找到库存数据", task.toLoggerString());
+            return false;
+        }
+//        Stock stock = stocks.get(0);
+        if (Objects.equals(stocks.get(0).getRemark(), "原材料")){
+//            //生成盘点回库单
+//            if(Objects.equals(task.getDestination(), "104")){
+//                //说明是大托盘回库，自动生成入库单并绑定母托，使用原材料页面查看然后可以生成任务。
+//                List<AppOrderIn> appOrderInList = new ArrayList<>();
+//                for(Stock stock : stocks){
+//                    AppOrderIn appOrderIn = new AppOrderIn();
+//                    appOrderIn.setRowId(WmsUtils.generateUUIDString());
+//                    appOrderIn.setGuid(task.getTaskId());//用来存盘点出库的taskid，在完成盘点回库后一起删除
+//                    appOrderIn.setInType(1);
+//                    appOrderIn.setBatchNo(stock.getBatchNo());
+//                    appOrderIn.setVehicleNo(task.getVehicleNo());
+//                    appOrderIn.setGoodsId(stock.getGoodsId());
+//                    appOrderIn.setGoodsNum(BigDecimal.valueOf(stock.getAvailableNum()));
+//                    appOrderIn.setWareHouse(stock.getWarehouseName());
+//                    appOrderIn.setOrderStatus(0);
+//                    appOrderIn.setCreateTime(LocalDate.now());
+//                    appOrderIn.setUpdateTime(LocalDateTime.now());
+//                    appOrderIn.setProductionDate(stock.getProductionDate());
+//                    appOrderIn.setCreatePerson("BACK");
+//                    appOrderIn.setRemark("通道三盘点回库");
+//                    appOrderInList.add(appOrderIn);
+//                }
+//                if(appOrderInMapper.insertList(appOrderInList) > 0){
+//                    log.info("盘点回库任务生成成功，任务：{}", task.toLoggerString());
+//                }
+//                log.info("盘点回库任务生成失败，任务：{}", task.toLoggerString());
+//            }
+//            // 如果是大托盘回库生成一条状态为666的回库任务，当用户确认时将状态改成待下发
+            if (Objects.equals(task.getDestination(), "104")){
+                // 更新库位表，占掉库位
+                Location updateLocationForBack = new Location();
+                updateLocationForBack.setLocationId(task.getOrigin());
+                updateLocationForBack.setLocationStatus(LocationStatus.OCCUPY.getCode());
+                updateLocationForBack.setVehicleId(task.getVehicleNo());
+                locationMapper.modifyLocation(updateLocationForBack); // 占掉库位
+                // 添加入库任务
+                Task taskByLitterMaterial = new Task();
+                taskByLitterMaterial.setTaskId(UUID.randomUUID().toString());
+                taskByLitterMaterial.setTaskType(TaskType.IN.getCode());
+                taskByLitterMaterial.setTaskStatus(666);
+                taskByLitterMaterial.setTaskGroup(UUID.randomUUID().toString());
+                taskByLitterMaterial.setOrigin("104");
+                taskByLitterMaterial.setDestination(task.getOrigin());
+                taskByLitterMaterial.setPickStand("大");
+                taskByLitterMaterial.setWeight(0.0);
+                taskByLitterMaterial.setVehicleNo(task.getVehicleNo());
+                taskByLitterMaterial.setCreateTime(task.getCreateTime());
+                taskByLitterMaterial.setUserName("原材料");
+                taskByLitterMaterial.setGoodsId(task.getGoodsId());//后面要将codeMessage拆成物料码和数量
+                taskByLitterMaterial.setOperateNum(task.getOperateNum());
+                taskByLitterMaterial.setTotalNum(task.getTotalNum());
+                taskByLitterMaterial.setTaskPriority(1);
+                taskByLitterMaterial.setProductionDate(task.getProductionDate());
+                taskByLitterMaterial.setRemark1("原材料");
+                //开始向任务表中添加任务
+                int addTask = taskMapper.addTask(taskByLitterMaterial);
+                if (addTask > 0){
+                    log.info("盘点出库完成添加入库任务成功，任务：{}", task.toLoggerString());
+                }else {
+                    log.error("盘点出库完成添加入库任务失败，任务：{}", task.toLoggerString());
+                }
+            }
+        }
+        // 备份Task表
+        Task taskRecordBack = new Task();
+        taskRecordBack.setTaskId(task.getTaskId());
+        taskRecordBack.setTaskType(3);
+        taskRecordBack.setGoodsName(task.getGoodsName());
+        taskRecordBack.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        taskRecordBack.setOrigin(task.getOrigin());
+        taskRecordBack.setDestination(task.getDestination());
+        taskRecordBack.setVehicleNo(task.getVehicleNo());
+        taskRecordBack.setCreateTime(task.getCreateTime());
+        taskRecordBack.setGoodsId(task.getGoodsId());
+        taskRecordBack.setOperateNum(task.getOperateNum());
+        taskRecordBack.setFinishTime(new Date());
+        taskRecordBack.setTaskPriority(task.getTaskPriority());
+        int x = taskRecordMapper.addTask(taskRecordBack);
+        if (x == 0){
+            log.info("盘点更新任务备份表失败，任务：{}，", task.toLoggerString());
+            for (int i = 0; i < 5; i++) {
+                int d = taskRecordMapper.addTask(taskRecordBack);
+                if (d != 0){
+                    log.info("盘点更新任务备份表重试成功，任务：{}", task.toLoggerString());
+                    break;
+                }
+            }
+        }else {
+            log.info("盘点更新任务备份表成功，任务：{}", task.toLoggerString());
+        }
+        // 删除task
+        int a = taskMapper.deleteTask(task.getTaskId());
+        if (a>0){
+            log.info("盘点出库，删除盘点出库任务成功");
+        }else {
+            log.info("盘点出库，删除盘点出库任务失败，即将重试");
+            taskMapper.deleteTask(task.getTaskId());
+        }
+        // 把库存状态更新成666
+        if (Objects.equals(task.getDestination(), "104")){
+            if(stockMapper.updateStockStatusWithLocationId(task.getOrigin(), 666) > 0){
+                log.info("三通道盘点出库将库存更新为特殊状态成功，托盘号：{}", task.getVehicleNo());
+                return true;
+            }else{
+                log.info("三通道盘点出库将库存更新为特殊状态失败，托盘号：{}", task.getVehicleNo());
+            }
+        }else{
+            if(stockMapper.deleteStockWithLocationId(task.getOrigin()) > 0){
+                log.info("一、二通道盘点出库删除库存成功，托盘号：{}", task.getVehicleNo());
+                return true;
+            }
+            log.info("一、二通道盘点出库删除库存失败，托盘号：{}", task.getVehicleNo());
+        }
+        return false;
+    }
+    /**
+     * 完成移库任务
+     * @param task 任务
+     * @return 完成结果
+     */
+    private boolean completeMoveTask(Task task) {
+        /* 找出任务，更新任务为完成；释放原库位；更新库存到新库位 */
+        // 完成任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 完成任务
+        // 释放原库位
+        // 释放库位
+        Location updateLocation = new Location();
+        updateLocation.setLocationId(task.getOrigin());
+        updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setVehicleId("");
+        locationMapper.modifyLocation(updateLocation); // 更新库位为空
+        // 占掉新库位，生成的时候会占，这里重复操作保护
+        Location occupyLocation = new Location();
+        occupyLocation.setLocationId(task.getDestination());
+        occupyLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+        occupyLocation.setVehicleId(task.getVehicleNo());
+        locationMapper.modifyLocation(occupyLocation); // 更新库位
+
+        // 空托需要更新载具表
+        if (Objects.equals(task.getVehicleNo(), "D99999999")){
+            int updateVehicle = vehicleMapper.updateLocation(task.getOrigin(), task.getDestination());
+            if (updateVehicle > 0){
+                log.info("空托更新载具表成功，任务：{}", task.toLoggerString());
+            }else {
+                log.error("空托更新载具表失败，任务：{}", task.toLoggerString());
+            }
+        }
+
+        // 更新库位
+        int updatedLocation = stockMapper.updateLocationAndStatus(task.getOrigin(), task.getDestination(), StockStatus.OK.getCode());
+        if(updatedLocation > 0){
+            log.info("移库库位更新成功，任务：{}", task.toLoggerString());
+            return true;
+        }
+        return false;
+    }
+
+    //endregion
+
+
+
+    //region 取消任务
+
+    /**
+     * 取消任务
+     * @param task 要完成的任务
+     * @return 操作结果
+     */
+    public boolean cancelTask(Task task) {
+        if(task == null) {
+            return false;
+        }
+        TaskType taskType = TaskType.getTaskType(task.getTaskType());
+        if(taskType == null) {
+            return false;
+        }
+        /* 根据任务类型判断 */
+        return switch (taskType) {
+            case IN -> cancelInTask(task);
+            case OUT -> cancelOutTask(task);
+            case INVENTORY -> cancelInventoryTask(task);
+            case MOVE -> cancelMoveTask(task);
+        };
+    }
+
+    /**
+     * 取消入库任务
+     * @param task 要取消的入库任务
+     * @return 结果
+     */
+    private boolean cancelInTask(Task task) {
+        /* 找出任务，取消该任务；找出该任务终点，更新库存为OK */
+        // 取消任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 取消任务
+        // 备份
+        //开始将chu库记录备份进task备份表
+        Task taskRecordBack = new Task();
+        taskRecordBack.setTaskId(task.getTaskId());
+        taskRecordBack.setTaskType(1);
+        taskRecordBack.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
+        taskRecordBack.setOrigin(task.getOrigin());
+        taskRecordBack.setDestination(task.getDestination());
+        taskRecordBack.setVehicleNo(task.getVehicleNo());
+        taskRecordBack.setCreateTime(task.getCreateTime());
+        taskRecordBack.setGoodsId(task.getGoodsId());
+        taskRecordBack.setOperateNum(task.getOperateNum());
+        taskRecordBack.setFinishTime(task.getFinishTime());
+        int x = taskRecordMapper.addTask(taskRecordBack);
+        if (x == 0){
+            log.info("入库取消更新任务备份表失败，任务：{}，", task.toLoggerString());
+            for (int i = 0; i < 5; i++) {
+                int d = taskRecordMapper.addTask(taskRecordBack);
+                if (d != 0){
+                    log.info("入库取消更新任务备份表重试成功，任务：{}", task.toLoggerString());
+                    break;
+                }
+            }
+        }else {
+            log.info("入库取消更新任务备份表成功，任务：{}", task.toLoggerString());
+        }
+        // 删除任务
+        taskMapper.deleteTask(task.getTaskId());
+        // 释放库位
+        Location updateLocation = new Location();
+        updateLocation.setLocationId(task.getDestination());
+        updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setVehicleId("");
+        locationMapper.modifyLocation(updateLocation); // 更新库位为空
+        // 更新库存为 ok ???????
+        int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
+        if(updateStock > 0){
+            log.info("入库取消更新库存成功，任务：{}", task.toLoggerString());
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 取消出库任务
+     * @param task 要取消的出库任务
+     * @return 执行结果
+     */
+    private boolean cancelOutTask(Task task) {
+        /* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
+        // 取消任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 取消任务
+        // 更新库存为 ok
+        int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
+        if(updateStock > 0){
+            log.info("出库取消更新库存成功，任务：{}", task.toLoggerString());
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 取消盘点任务
+     * @param task 任务
+     * @return 取消结果
+     */
+    private boolean cancelInventoryTask(Task task) {
+        /* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
+        // 取消任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 取消任务
+        // 更新库存为 ok
+        int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
+        if(updateStock > 0){
+            log.info("盘点出库取消更新库存成功，任务：{}", task.toLoggerString());
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 取消移库任务
+     * @param task 任务
+     * @return 取消结果
+     */
+    private boolean cancelMoveTask(Task task) {
+        /* 找出任务，更新任务为取消；释放新库位；更新库存为OK */
+        // 取消任务
+        Task completeTask = new Task();
+        completeTask.setTaskId(task.getTaskId());
+        completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
+        completeTask.setFinishTime(new Date());
+        taskMapper.executeTask(completeTask); // 取消任务
+        // 释放库位
+        Location updateLocation = new Location();
+        updateLocation.setLocationId(task.getDestination());
+        updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setVehicleId("");
+        locationMapper.modifyLocation(updateLocation); // 更新库位为空
+        // 更新库位
+        int updatedLocation = stockMapper.updateStockStatusWithLocationId(task.getOrigin(), StockStatus.OK.getCode());
+        if(updatedLocation > 0){
+            log.info("移库取消库位状态更新成功，任务：{}", task.toLoggerString());
+            return true;
+        }
+        return false;
+    }
+
+
+    //endregion
+
+
+
+
+}

src/main/java/com/wms/bussiness/TaskTimer.java

@@ -0,0 +1,24 @@
+package com.wms.bussiness;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+
+/**
+ * 任务定时器
+ */
+@Component
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class TaskTimer {
+
+
+
+
+
+
+
+
+
+
+}

src/main/java/com/wms/config/InitLocalConfig.java

@@ -0,0 +1,57 @@
+package com.wms.config;
+
+//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.wms.entity.table.Config;
+import com.wms.entity.table.Location;
+import com.wms.service.ConfigService;
+import com.wms.service.LocationService;
+import lombok.RequiredArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Component
+@Order(1)
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class InitLocalConfig implements ApplicationRunner {
+    /**
+     * 配置类
+     */
+    private final ConfigService configService;
+    /**
+     * 库位服务
+     */
+    private final LocationService locationService;
+
+
+    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
+    public static Map<String, String> configMap = new HashMap<>();
+    public static Map<String, Location> instantLocationMap = new HashMap<>();
+    public static List<LocalDate> localWorkDateList = new ArrayList<>();
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        logger.info("加载设置到内存中...");
+        logger.info("加载配置到内存中...");
+    }
+//    public void run(ApplicationArguments args) {
+//        List<Config> configs = configService.selectConfigs("");
+//        if (!configs.isEmpty()) {
+//            for (Config config : configs) {
+//                configMap.put(config.getConfigKey(), config.getConfigValue());
+//                logger.info("导入系统配置成功---{}：{}", config.getConfigName(), config.getConfigValue());
+//                logger.info("加载配置到内存中...");
+//            }
+//        }
+//    }
+}

src/main/java/com/wms/config/PageHelperConfig.java

@@ -0,0 +1,23 @@
+package com.wms.config;
+
+import com.github.pagehelper.PageHelper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.Properties;
+
+@Configuration
+public class PageHelperConfig {
+    @Bean
+    public PageHelper pageHelper() {
+        PageHelper pageHelper = new PageHelper();
+        //添加配置，也可以指定文件路径
+        Properties p = new Properties();
+        p.setProperty("helperDialect", "sqlserver2012");
+        p.setProperty("reasonable", "true");
+        p.setProperty("supportMethodsArguments", "true");
+        p.setProperty("params", "count=countSql");
+        pageHelper.setProperties(p);
+        return pageHelper;
+    }
+}

src/main/java/com/wms/constants/WmsConstants.java

@@ -0,0 +1,68 @@
+package com.wms.constants;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.google.common.collect.ImmutableMap;
+import com.wms.constants.enums.WcsTaskStatus;
+import com.wms.constants.enums.WmsTaskStatus;
+import com.wms.entity.table.PartInfo;
+
+/**
+ * WMS系统所需的常量
+ * @author 梁州
+ * @date  2023/2/13
+ */
+public class WmsConstants {
+
+    public static String EMPTY_STRING = "";
+
+    public static BigDecimal NUMBER_ONE = BigDecimal.valueOf(1);
+
+    public static String ROOT_MENU_ID = "0";
+
+    public static Map<String, PartInfo> partInfoMap = new HashMap<>();
+
+    public static void initMap() {
+        //
+    }
+
+    /**
+     * 虚拟库位设备号
+     */
+    public static Integer VIRTUAL_LOCATION_EQUIP_ID = 11;
+
+    /**
+     * 入库库位类型：虚拟库位
+     */
+    public static String VIRTUAL_LOCATION_IN = "0";
+
+    /**
+     * 虚拟库位库区编码
+     */
+    public static int VIRTUAL_LOCATION_AREA_ID = 99;
+
+    /**
+     * 空托盘编号
+     */
+    public static String EMPTY_STOCK_GOODS_ID = "000000000";
+    /**
+     * 空托盘批次号
+     */
+    public static String EMPTY_STOCK_BATCH_NO = "EMPTY";
+
+    /**
+     * 设备号对应入库口
+     */
+    public static Map<Integer, Integer> LOCATOR_AREA_MAP = ImmutableMap.<Integer, Integer>builder()
+            .put(WcsTaskStatus.WAIT.getCode(), WmsTaskStatus.WAIT.getCode())
+            .put(WcsTaskStatus.RUN.getCode(), WmsTaskStatus.RUN.getCode())
+            .put(WcsTaskStatus.LEAVE.getCode(), WmsTaskStatus.RUN.getCode())
+            .put(WcsTaskStatus.PARK.getCode(), WmsTaskStatus.RUN.getCode())
+            .put(WcsTaskStatus.ARRIVE.getCode(), WmsTaskStatus.RUN.getCode())
+            .put(WcsTaskStatus.FINISH.getCode(), WmsTaskStatus.FINISH.getCode())
+            .put(WcsTaskStatus.CANCEL.getCode(), WmsTaskStatus.CANCEL.getCode())
+            .put(WcsTaskStatus.EXCEPTION.getCode(), WmsTaskStatus.EXCEPTION.getCode())
+            .build();
+}

src/main/java/com/wms/constants/enums/ConfigMapKeyEnum.java

@@ -0,0 +1,30 @@
+package com.wms.constants.enums;
+
+public enum ConfigMapKeyEnum {
+    MAX_WEIGHT("MAX_WEIGHT"),
+    URL_WCS_TASK("URL_WCS_TASK"),
+    URL_NEW_DESTINATION("URL_NEW_DESTINATION"),
+    URL_WCS_PICK_TASK("URL_WCS_PICK_TASK"),
+    URL_WCS_CANCEL_PICK_TASK("URL_WCS_CANCEL_PICK_TASK"),
+    URL_WCS_E_TASK("URL_WCS_E_TASK"),
+    URL_WCS_DISPOSE_VEHICLE("URL_WCS_DISPOSE_VEHICLE"),
+    CREATE_WORK("CREATE_WORK"),
+    START_WORK("START_WORK"),
+    SEND_TASK("SEND_TASK"),
+    ALLOW_EMPTY_BACK("ALLOW_EMPTY_BACK"),
+    SEND_PICK_OUT_TASK("SEND_PICK_OUT_TASK"),
+    MAX_VEHICLE_NUMS("MAX_VEHICLE_NUMS"),
+    MAX_WCS_ACCEPT_NUMS("MAX_WCS_ACCEPT_NUMS"),
+    SLOC_FILTER_STRING("SLOC_FILTER_STRING"),
+    URL_WCS_CHANGE_TASK("URL_WCS_CHANGE_TASK"),
+    LOG_DELETE_INTERVAL("LOG_DELETE_INTERVAL"),
+    RECORD_DELETE_INTERVAL("RECORD_DELETE_INTERVAL"),
+    IMPORTANT_RECORD_DELETE_INTERVAL("IMPORTANT_RECORD_DELETE_INTERVAL");
+    private final String configKey;
+    ConfigMapKeyEnum(String configKey) {
+        this.configKey = configKey;
+    }
+    public String getConfigKey() {
+        return configKey;
+    }
+}

src/main/java/com/wms/constants/enums/GoodsStatus.java

@@ -0,0 +1,29 @@
+package com.wms.constants.enums;
+
+/**
+ * 物料状态枚举
+ */
+public enum GoodsStatus {
+    OK(0, "合格"),
+    BAD(1, "不合格"),
+    DELAY(2, "延期"),
+    OVERDUE(3, "过期"),
+    SCRAP(5, "长时间未使用");
+
+    private final Integer code;
+
+    private final String value;
+
+    GoodsStatus(Integer code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/com/wms/constants/enums/KateTaskStatus.java

@@ -0,0 +1,25 @@
+package com.wms.constants.enums;
+
+public enum KateTaskStatus {
+    NEW(0, "待下发"),
+    WAIT(1, "已下发"),
+    RUN(2, "执行中"),
+    PICKING(3, "正在拣货"),
+    FINISH(5, "任务完成");
+
+    private final Integer code;
+    private final String name;
+
+    KateTaskStatus(Integer code, String name) {
+        this.code = code;
+        this.name = name;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/com/wms/constants/enums/LocationStatus.java

@@ -0,0 +1,27 @@
+package com.wms.constants.enums;
+
+/**
+ * 库位状态枚举
+ * /// 托盘状态和站台状态通用
+ */
+public enum LocationStatus {
+    EMPTY(0, "空闲"),
+    OCCUPY(1, "占用");
+
+    private final Integer code;
+
+    private final String value;
+
+    LocationStatus(Integer code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/com/wms/constants/enums/OrderCheckStatusEnum.java

@@ -0,0 +1,28 @@
+package com.wms.constants.enums;
+
+import lombok.Getter;
+
+/**
+ * 盘点表状态枚举
+ */
+@Getter
+public enum OrderCheckStatusEnum {
+
+    CREATED(0, "已创建"),
+
+    CHECKING(1, "盘点中"),
+
+    CHECKED(2, "已盘点"),
+
+    CANCELED(3, "已取消");
+
+
+    private final int code;
+    private final String desc;
+
+    OrderCheckStatusEnum(int code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+}

src/main/java/com/wms/constants/enums/OrderInStatusEnum.java

@@ -0,0 +1,26 @@
+package com.wms.constants.enums;
+
+import lombok.Data;
+import lombok.Getter;
+
+/**
+ * 订单入库状态枚举
+ *
+ * @author 菻蔃
+ */
+@Getter
+public enum OrderInStatusEnum {
+    CREATE(0, "创建"),
+    IN(1, "入库中"),
+    BINDING(2, "已绑定"),
+    ;
+
+    private final int code;
+    private final String desc;
+
+    OrderInStatusEnum(int code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+}

src/main/java/com/wms/constants/enums/OrderOutStatusEnum.java

@@ -0,0 +1,27 @@
+package com.wms.constants.enums;
+
+import lombok.Getter;
+
+/**
+ * 出库单状态的枚举
+ */
+@Getter
+public enum OrderOutStatusEnum {
+
+    CREATED(0, "已创建"),
+    RUNNING(1, "执行中"),
+    EXPRESS(9, "执行异常"),
+    UNSTOCK(76, "没有库存"),
+    UNENOUGH(77, "库存不足"),
+    FINISHED(100, "已完成");
+    //RUNNING(1, "执行中");
+
+
+    private final int code;
+    private final String desc;
+
+    OrderOutStatusEnum(int code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+}

src/main/java/com/wms/constants/enums/ResponseCode.java

@@ -0,0 +1,27 @@
+package com.wms.constants.enums;
+
+/**
+ * 接口响应码枚举
+ */
+public enum ResponseCode {
+    OK(0, "正常"),
+    WARNING(200, "警告"),
+    ERROR(999, "异常");
+
+    private final Integer code;
+
+    private final String value;
+
+    ResponseCode(Integer code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/com/wms/constants/enums/StockStatus.java

@@ -0,0 +1,34 @@
+package com.wms.constants.enums;
+
+/**
+ * 库存状态枚举
+ */
+public enum StockStatus {
+    WAIT_IN(-2, "待入库"),
+    IN_ING(-1, "正在入库"),
+    OK(0, "库存正常"),
+    OUT(1, "准备出库"),
+    MOVING(2, "正在出库"),
+    TRANS(3, "出库完成"),
+    PICKING(4, "站台拣货中"),
+    INVENTORY_OUT(5, "站台盘点中"),
+    BACKING(6, "正在回库"),
+    LOCK(9, "库存锁定");
+
+    private final Integer code;
+
+    private final String value;
+
+    StockStatus(Integer code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/com/wms/constants/enums/TaskType.java

@@ -0,0 +1,37 @@
+package com.wms.constants.enums;
+
+/**
+ * 任务类型枚举
+ */
+public enum TaskType {
+    IN(1, "入库"),
+    OUT(2, "出库"),
+    INVENTORY(3, "盘点"),
+    MOVE(9, "移库");
+
+    private final Integer code;
+
+    private final String value;
+
+    TaskType(Integer code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public static TaskType getTaskType(Integer code) {
+        for (TaskType taskType : TaskType.values()) {
+            if (taskType.getCode().equals(code)) {
+                return taskType;
+            }
+        }
+        return null;
+    }
+}

src/main/java/com/wms/constants/enums/UrlEnums.java

@@ -0,0 +1,32 @@
+package com.wms.constants.enums;
+//172.21.80.151
+public enum UrlEnums {
+    //URL_WMS_TO_WCS_SEND_TASK("WMS向WCS发送任务", "http://192.168.103.165:18990/api/wms/wmsTask/setStackerTask"),
+    URL_WMS_TO_WCS_SEND_TASK("WMS向WCS发送任务", "http://10.90.85.68:18990/api/wms/wmsTask/setStackerTask"),
+    URL_WMS_TO_WCS_CHANGE_TASK("WMS请求变更任务状态", "http://10.90.85.68:18990/api/Wms/WmsTask/ChangeTaskStatus"),
+    URL_WMS_TO_WCS_CONTAINER_TASK("WMS向四向车发送任务","http://172.21.80.150:9991/api/Wcs/PushTask"),
+    URL_WMS_TO_WCS_CONTAINERIN_TASK("WMS向四向车发送入库任务","http://172.21.80.150:19990/api/container/createInstoreTask");
+    //URL_WMS_TO_MES_IN("扫码上架", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/LotGround"),
+//    URL_WMS_TO_MES_OUT("批次出库", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/ReceiptOut"),
+//    URL_WMS_TO_MES_INVENTORY("盘点执行", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/InventoryResult"),
+//    URL_WMS_TO_MES_STOCK("库存", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/WMSStorage");
+    //URL_WMS_TO_MES_MOVE("批次调整", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/LotAD");
+
+
+
+    private final String description;
+    private final String value;
+
+    UrlEnums(String description, String value) {
+        this.description = description;
+        this.value = value;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/com/wms/constants/enums/VehicleStatus.java

@@ -0,0 +1,27 @@
+package com.wms.constants.enums;
+
+/**
+ * 载具状态
+ */
+public enum VehicleStatus {
+    IN(1, "入库中"),
+    ON(2, "在库中"),
+    OUT(3, "出库中");
+
+    private final Integer code;
+
+    private final String value;
+
+    VehicleStatus(Integer code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/com/wms/constants/enums/WcsTaskStatus.java

@@ -0,0 +1,31 @@
+package com.wms.constants.enums;
+
+/**
+ * Wcs任务状态的枚举
+ */
+public enum WcsTaskStatus {
+    WAIT(1, "任务排队中"),
+    RUN(2, "任务开始执行"),
+    LEAVE(3, "任务已经离开初始位置"),
+    PARK(4, "任务到达中间点"),
+    ARRIVE(5, "任务到达目的地"),
+    FINISH(100, "任务完成"),
+    CANCEL(998, "任务取消"),
+    EXCEPTION(999, "任务异常");
+
+    private final Integer code;
+    private final String name;
+
+    WcsTaskStatus(Integer code, String name) {
+        this.code = code;
+        this.name = name;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/com/wms/constants/enums/WmsTaskStatus.java

@@ -0,0 +1,35 @@
+package com.wms.constants.enums;
+
+/**
+ * Wms任务状态的枚举
+ */
+public enum WmsTaskStatus {
+    NEW(0, "任务新建，待下发"),
+    WAIT(1, "任务已下发"),
+    RUN(2, "任务开始执行"),
+    OUT_SUCCESS(3, "出库完成"),
+    TRANS_MOVE(4, "输送线转运中"),
+    ARRIVE_STAND(5, "到达拣选站台"),
+    PICKING(6, "正在拣货"),
+    BACKING(7, "正在回库"),
+    INVENTORY(8, "盘点中"),
+    FINISH(100, "任务完成"),
+    CANCEL(998, "任务取消"),
+    EXCEPTION(999, "任务异常");
+
+    private final Integer code;
+    private final String name;
+
+    WmsTaskStatus(Integer code, String name) {
+        this.code = code;
+        this.name = name;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/com/wms/controller/BaseController.java

@@ -0,0 +1,8 @@
+package com.wms.controller;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class BaseController {
+    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
+}

src/main/java/com/wms/controller/ConfigController.java

@@ -0,0 +1,87 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.page.PageDomain;
+import com.wms.entity.page.TableRequest;
+import com.wms.entity.page.TableResponse;
+import com.wms.entity.table.Config;
+import com.wms.service.ConfigService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.StringUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * WMS系统配置控制类
+ * @author 梁州
+ * @date  2023/3/23
+ */
+@Controller
+@CrossOrigin
+@RequestMapping(value = "/wms/config")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class ConfigController extends BaseController{
+    /**
+     * 系统配置服务
+     */
+    private final ConfigService configService;
+    /**
+     * 请求头部信息
+     */
+    private final HttpServletRequest servletRequest;
+
+    /**
+     * 查找所有配置
+     * @return 配置
+     */
+    @GetMapping("/getConfigs")
+    @ResponseBody
+    public List<Config> getConfigs(){
+        logger.info("查询系统配置");
+        return configService.selectConfigs("");
+    }
+
+    /**
+     * 更新系统配置
+     *
+     * @param config 配置
+     * @return 结果
+     */
+    @PostMapping("/updateConfig")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateConfig(@RequestBody Config config) {
+        logger.info("更新系统配置，{}：{}", config.getConfigName(), config.getConfigValue());
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            configService.updateConfig(config);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("更新系统配置错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("更新系统配置成功！");
+        return JSON.toJSONString(rsp);
+    }
+}

src/main/java/com/wms/controller/DisplayController.java

@@ -0,0 +1,133 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.wms.constants.WmsConstants;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.display.LocationData;
+import com.wms.entity.app.display.LocationInfo;
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.dto.orderOut.queryOrderOutRequest;
+import com.wms.entity.table.Location;
+import com.wms.entity.table.OrderOut;
+import com.wms.entity.table.Stock;
+import com.wms.entity.table.oledIn;
+import com.wms.service.IOrderOutService;
+import com.wms.service.LocationService;
+import com.wms.service.StockService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.StringUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+@Controller
+@CrossOrigin
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+@RequestMapping(value = "/api/query")
+public class DisplayController extends BaseController{
+    private final StockService stockService;
+    private final LocationService locationService;
+    private final HttpServletRequest servletRequest;
+    private final IOrderOutService orderOutService;
+
+    /**
+     * 大屏查询库位信息
+     * @param location 参数---库位
+     * @return 结果
+     */
+    @GetMapping("/queryLocationInfo")
+    @ResponseBody
+    public String queryLocationInfo(@RequestParam String location) {
+        logger.info("接收到查询大屏库位信息请求，ip地址：{}，参数：{}", HttpUtils.getIpAddr(servletRequest), location);
+        ResponseEntity response = new ResponseEntity();
+        if (StringUtils.isEmpty(location)) {
+            logger.error("查询失败，参数中库位号为空");
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("查询失败，参数中库位号为空");
+            return JSON.toJSONString(response);
+        }
+        Location locationQuery = new Location();
+        locationQuery.setLocationId(location);
+        List<Location> locations = locationService.selLocations(locationQuery);
+        if (locations.size() == 0) {
+            logger.error("查询失败，该库位立体库中不存在");
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("查询失败，请检查库位号正确性");
+            return JSON.toJSONString(response);
+        }
+        Location currentLocation = locations.get(0);
+        String vehicleNo = currentLocation.getVehicleId();
+        if (StringUtils.isEmpty(vehicleNo)) {
+            // 设定
+            LocationInfo returnData = new LocationInfo();
+            returnData.setLocationId(location);
+            returnData.setVehicleNo(WmsConstants.EMPTY_STRING);
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("查询成功");
+            response.setReturnData(returnData);
+            return JSON.toJSONString(response);
+        }
+        // 查询库存
+        Stock stockQuery = new Stock();
+        stockQuery.setLocationId(location);
+        stockQuery.setVehicleId(vehicleNo);
+        List<Stock> stocks = stockService.selStocks(stockQuery);
+        List<LocationData> locationData = new LinkedList<>();
+        for (Stock tempStock : stocks) {
+            LocationData tempData = new LocationData();
+            tempData.setGoodsId(tempStock.getGoodsId());
+            tempData.setGoodsName(tempStock.getGoodsName());
+            tempData.setGoodsNum(tempStock.getRealNum());
+            locationData.add(tempData);
+        }
+        // 设定
+        LocationInfo returnData = new LocationInfo();
+        returnData.setLocationId(location);
+        returnData.setVehicleNo(WmsConstants.EMPTY_STRING);
+        returnData.setLocationData(locationData);
+        response.setCode(ResponseCode.OK.getCode());
+        response.setMessage("查询成功");
+        response.setReturnData(returnData);
+        return JSON.toJSONString(response);
+    }
+
+    /**
+     * 查询所有库位
+     * @return 结果
+     */
+    @GetMapping("/getAllLocations")
+    @ResponseBody
+    public String queryLocationInfo() {
+        logger.info("接收到查询大屏所有库位信息请求，ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        return JSON.toJSONString(locationService.selLocations(new Location()));
+    }
+
+    /**
+     * 查询所有出库单
+     * @return 结果
+     */
+    @GetMapping("/oledForOrderOut")
+    @ResponseBody
+    public ResponseEntity oledForOrderOut(queryOrderOutRequest request) {
+        //logger.info("接收到查询大屏所有出库单请求，ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        ResponseEntity rsp = new ResponseEntity();
+        List<OrderOut> outList = orderOutService.getAllOrderOut(request);
+        if (outList == null || outList.isEmpty()) {
+            rsp.setCode(0);
+            rsp.setMessage("fail");
+            rsp.setReturnData(null);
+        } else {
+            rsp.setCode(200);
+            rsp.setMessage("success");
+            rsp.setReturnData(outList);
+        }
+        return rsp;
+    }
+}

src/main/java/com/wms/controller/ExcelController.java

@@ -0,0 +1,198 @@
+package com.wms.controller;
+
+import com.wms.constants.enums.*;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.vo.FileVo;
+import com.wms.entity.dto.orderOut.queryOrderOutRequest;
+import com.wms.entity.table.*;
+import com.wms.mapper.AppOrderInMapper;
+import com.wms.mapper.OrderOutMapper;
+import com.wms.service.*;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.excel.listener.UploadTestListener;
+import com.wms.utils.excel.vo.*;
+import com.alibaba.excel.EasyExcel;
+import com.alibaba.fastjson2.JSON;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.utils.excel.ExcelUtils;
+import com.wms.utils.excel.listener.UploadKateOrdersListener;
+import com.wms.utils.excel.vo.KateOrdersExcelVo;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.wms.utils.HttpUtils.getIpAddr;
+import static com.wms.utils.StringUtils.convertJsonString;
+
+
+/**
+ *
+ */
+@Controller
+@CrossOrigin
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+@RequestMapping(value = "/wms/excel")
+public class ExcelController extends BaseController {
+    private final StockService stockService;// 库存服务
+    private final PartInfoService partInfoService;// 零件服务
+    private final HttpServletRequest servletRequest;// 请求服务
+    private final TaskRecordService taskRecordService;// 任务记录服务
+    //private final IOrderOutService orderOutService;
+    private final IOrderOutService orderOutService;
+    private final OrderOutMapper appOrderOutMapper;
+//    private final KateOrdersService kateOrdersService;// 工单服务
+//    private final UploadRecordService uploadRecordService;// 上传服务
+
+    private final List<String> uploadFileHashStringList = new ArrayList<>();
+
+    /**
+     * 导入零件信息
+     *
+     * @param file 文件
+     * @return 导入结果
+     */
+    @PostMapping("/uploadPartInfos")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String uploadPartInfos(@RequestPart("file") MultipartFile file) {
+        logger.info("接收到导入零件信息请求，ip地址：{}", getIpAddr(servletRequest));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            List<PartInfo> files = ExcelUtils.readMultipartFile(file, PartInfo.class);
+            // 添加进物料表
+            for (PartInfo pageInfo : files) {
+                if (partInfoService.selPartByPartNo(pageInfo.getMaterial()) != null) {// 当前零件号的数据已经存在过
+                    partInfoService.modifyPart(pageInfo);
+                } else {// 新零件
+                    partInfoService.addPart(pageInfo);
+                }
+            }
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("导入excel成功");
+            response.setReturnData(files);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage(e.getMessage());
+        }
+        return JSON.toJSONString(response);
+    }
+
+    /**
+     * 导出库存数据
+     *
+     * @param response 请求
+     */
+    @GetMapping("/downloadStockExcel")
+    @ResponseBody
+    public void downloadStockExcel(HttpServletResponse response) {
+        List<Stock> stocks = stockService.selStocks(new Stock());
+        ExcelUtils.export(response, "库存报表", stocks, Stock.class);
+    }
+
+    /**
+     * 导出入库记录
+     *
+     * @param response 请求
+     */
+    @GetMapping("/downloadRukuExcel")
+    @ResponseBody
+    public void downloadRukuExcel(HttpServletResponse response) {
+        List<Task> ruku = taskRecordService.selTasks(new Task());
+        ExcelUtils.export(response, "入库记录报表", ruku, Task.class);
+    }
+
+    /**
+     * 导出物料信息
+     *
+     * @param response 请求
+     */
+    @GetMapping("/downloadMaterialExcel")
+    @ResponseBody
+    public void downloadMaterialExcel(HttpServletResponse response) {
+        List<PartInfo> Material = partInfoService.selParts(new PartInfo());
+        ExcelUtils.export(response, "物料信息", Material, PartInfo.class);
+    }
+
+    /**
+     * 导出工单模板
+     * @param response 文件
+     * @return 导入结果
+     */
+    @GetMapping("/downloadOrderOutTable")
+    @ResponseBody
+    public void downloadOrderOutTable(HttpServletResponse response) {
+        //List<PartInfo> Material = partInfoService.selParts(new PartInfo());
+        List<ExcelTemplateVo> Material = new ArrayList<>();
+        ExcelUtils.export(response, "出库工单模板", Material, ExcelTemplateVo.class);
+    }
+
+    /**
+     * 导出当前工单所有数据
+     * @param response 文件
+     * @return 导入结果
+     */
+    @GetMapping("/downloadOrderOutTableNow")
+    @ResponseBody
+    public void downloadOrderOutTableNow(HttpServletResponse response) {
+
+        OrderOut orderOut = new OrderOut();
+        orderOut.setOrderType(1);
+        List<OrderOut> Material = appOrderOutMapper.queryWithOrderStatus(orderOut);
+        ExcelUtils.export(response, "出库工单模板", Material, OrderOut.class);
+    }
+
+
+
+    /**
+     * 导入工单
+     *
+     * @param file 文件
+     * @return 导入结果
+     */
+    @PostMapping("/uploadKateOrders")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String uploadKateOrders(@RequestPart("file") MultipartFile file) {
+        logger.info("导入工单，请求ip：{}", getIpAddr(servletRequest));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            // 先查看是否还存在未完成的工单，如果存在则不允许入库
+            OrderOut orderOut = new OrderOut();
+            orderOut.setOrderType(1);
+            List<OrderOut> orderOutList = appOrderOutMapper.query(orderOut);
+            if (!orderOutList.isEmpty()){
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("存在未完成的工单任务，请完成后重试！");
+                return convertJsonString(response);
+            }
+            // 导入excel
+            EasyExcel.read(file.getInputStream(), ExcelTemplateVo.class, new UploadTestListener(orderOutService)).sheet(1).headRowNumber(2).doRead();
+
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("导入成功。");
+            return convertJsonString(response);
+        } catch (Exception e) {
+            logger.error("导入异常：{}", convertJsonString(e));
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("导入工单异常。");
+            return convertJsonString(response);
+        }
+    }
+
+}

src/main/java/com/wms/controller/GoodsController.java

@@ -0,0 +1,373 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.dto.goodsRequest;
+import com.wms.entity.page.PageDomain;
+import com.wms.entity.page.TableRequest;
+import com.wms.entity.page.TableResponse;
+import com.wms.entity.table.Goods;
+import com.wms.entity.table.PartInfo;
+import com.wms.entity.table.VechileList;
+import com.wms.entity.table.Vehicle;
+import com.wms.mapper.VehicleIistMapper;
+import com.wms.service.GoodsService;
+import com.wms.service.PartInfoService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.StringUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+
+/**
+ * WMS物料控制类
+ * @author 梁州
+ * @date  2023/3/9
+ */
+@Controller
+@CrossOrigin
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+@RequestMapping(value = "/wms/goods")
+public class GoodsController extends BaseController{
+
+    /**
+     * 物料服务
+     */
+    private final GoodsService goodsService;
+    /**
+     * 零件服务
+     */
+    private final PartInfoService partInfoService;
+    /**
+     * 请求头部信息
+     */
+    private final HttpServletRequest servletRequest;
+
+    private final VehicleIistMapper vehicleIistMapper;
+
+    /**
+     * 查找所有零件信息
+     */
+    @PostMapping("/getPartInfo")
+    @ResponseBody
+    public String getPartInfo(@RequestBody TableRequest<PartInfo, String> tableRequest){
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到查询零件数据请求：{}", JSON.toJSONString(tableRequest));
+        TableResponse tblResp = new TableResponse();
+        // 解析请求数据
+        if (tableRequest == null || tableRequest.getPage() == null) {
+            tblResp.setCode(ResponseCode.ERROR.getCode());
+            tblResp.setMessage("请求数据为空，无法处理！");
+            logger.error("请求数据为空，无法处理！");
+            return JSON.toJSONString(tblResp);
+        }
+        // 处理分页信息
+        PageDomain pageRequest = tableRequest.getPage();
+//        String[] orderByArr = {"location_id", "vehicle_id", "goods_id", "batch_no", "remain_num", "expiration_date", "create_time"};
+        String orderByStr = "material asc";
+
+//        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
+//            orderByStr = pageRequest.getOrderBy();
+//        } else {
+//            // 默认排序
+//            orderByStr = "expiration_date desc";
+//        }
+
+        PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
+        List<PartInfo> parts = partInfoService.selParts(tableRequest.getParam());
+        PageInfo<PartInfo> partPageInfo = new PageInfo<>(parts);
+        tblResp.setCode(ResponseCode.OK.getCode());
+        tblResp.setMessage("查询零件信息成功！");
+        tblResp.setRows(partPageInfo.getList());
+        tblResp.setTotal(partPageInfo.getTotal());
+        return JSON.toJSONString(tblResp);
+    }
+
+
+
+    /**
+     * 查找所有母托信息
+     */
+    @PostMapping("/getAllVechileData")
+    @ResponseBody
+    public String getAllVechileData(@RequestBody VechileList vechileId){
+        ResponseEntity rsp = new ResponseEntity();
+//        VechileList vehicle = new VechileList();
+//        vehicle.setVehicleId(vechileId);
+        List<VechileList> vechileLists = vehicleIistMapper.select(vechileId);
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("查询母托信息成功！");
+        rsp.setReturnData(vechileLists);
+        return JSON.toJSONString(rsp);
+    }
+
+
+    /**
+     * 新增母托数据
+     */
+    @PostMapping("/addVechile")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String addVechile(@RequestBody VechileList vechileId){
+        ResponseEntity rsp = new ResponseEntity();
+        List<VechileList> vechileLists = vehicleIistMapper.select(vechileId);
+        if (vechileLists.isEmpty()){
+            if (vehicleIistMapper.insert(vechileId) > 0){
+                rsp.setCode(ResponseCode.OK.getCode());
+                rsp.setMessage("新增母托信息成功！");
+                return JSON.toJSONString(rsp);
+            }
+        }
+        rsp.setCode(ResponseCode.ERROR.getCode());
+        rsp.setMessage("该母托已存在！");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 删除零件信息
+     */
+    @PostMapping("/delete1")
+    @ResponseBody
+    public String deleteVehicle(@RequestBody VechileList vechileId) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        ResponseEntity rsp = new ResponseEntity();
+        if(vehicleIistMapper.delete(vechileId) > 0){
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("删除母托信息成功！");
+            return JSON.toJSONString(rsp);
+        }
+        rsp.setCode(ResponseCode.ERROR.getCode());
+        rsp.setMessage("删除母托信息失败！");
+        return JSON.toJSONString(rsp);
+    }
+
+
+
+
+
+    /**
+     * 添加零件信息
+     *
+     * @param
+     * @return 结果
+     */
+    @PostMapping("/addPartInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public WmsApiResponse<Object> addPartInfo(@RequestBody goodsRequest request) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        PartInfo partInfo = new PartInfo();
+        partInfo.setMaterial(request.getGoodsId());
+        if (!partInfoService.selParts(partInfo).isEmpty()) {
+            return new WmsApiResponse<>(1, "该零件已存在", null);
+        }
+        if (Objects.equals(request.getEfSelect(), "E")){
+            partInfo.setItemDesc("发动机");
+        }else{
+            partInfo.setItemDesc("原材料");
+        }
+        if (partInfoService.addPart(partInfo) > 0){
+            return new WmsApiResponse<>(0, "添加零件成功", null);
+        }else{
+            return new WmsApiResponse<>(1, "添加零件失败", null);
+        }
+    }
+
+    /**
+     * 更新零件信息
+     *
+     * @param partInfo 零件信息
+     * @return 结果
+     */
+    @PostMapping("/updatePartInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updatePartInfo(@RequestBody PartInfo partInfo) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到更新零件信息请求：{}", JSON.toJSONString(partInfo));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (StringUtils.isEmpty(partInfo.getMaterial())) {// 箱号为空，不执行
+                logger.error("请求零件号为空");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("请求零件号为空");
+                return JSON.toJSONString(rsp);
+            }
+            partInfoService.modifyPart(partInfo);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("发生异常：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("更新零件信息成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 更新物料信息
+     *
+     * @param goods 物料
+     * @return 结果
+     */
+    @PostMapping("/updateGoodsInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateGoodsInfo(@RequestBody Goods goods) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            goodsService.modifyGoods(goods);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("更新物料信息发生错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        logger.info("更新物料信息成功：{}", goods.toLoggerString());
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("更新物料信息成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    @PostMapping("/queryPartInfoByPartNo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String queryPartInfoByPartNo(@RequestBody PartInfo partInfo) {
+        logger.info("前台查询零件数据");
+        ResponseEntity rsp = new ResponseEntity();
+        if (partInfo == null || StringUtils.isEmpty(partInfo.getMaterial())) {
+            logger.info("请求查询的参数为空");
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("请求查询的参数为空");
+            return JSON.toJSONString(rsp);
+        }
+        try {
+            PartInfo partInfoNeed = partInfoService.selPartByPartNo(partInfo.getMaterial());
+            if (partInfoNeed == null) {
+                logger.info("查询零件信息发生错误，零件号：{}", partInfo.getMaterial());
+                // 返回其他异常
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("查询的零件信息为空");
+                return JSON.toJSONString(rsp);
+            }
+            rsp.setReturnData(partInfoNeed);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("查询零件信息发生错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        logger.info("查询零件信息成功");
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("查询零件信息成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    @PostMapping("/queryPartNo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String queryPartNo(@RequestBody PartInfo partInfo) {
+        logger.info("前台查询零件数据");
+        ResponseEntity rsp = new ResponseEntity();
+        if (partInfo == null || StringUtils.isEmpty(partInfo.getMaterial())) {
+            logger.info("请求查询的参数为空");
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("请求查询的参数为空");
+            return JSON.toJSONString(rsp);
+        }
+        try {
+            PartInfo query = new PartInfo();
+            query.setMaterial(partInfo.getMaterial());
+            List<PartInfo> partInfoNeed = partInfoService.selParts(query);
+            if (partInfoNeed.size() == 0) {
+                logger.info("查询零件信息发生错误，零件号：{}", partInfo.getMaterial());
+                // 返回其他异常
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("查询的零件信息为空");
+                return JSON.toJSONString(rsp);
+            }
+            rsp.setReturnData(partInfoNeed);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("查询零件信息发生错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        logger.info("查询零件信息成功");
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("查询零件信息成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 删除当前零件信息
+     *
+     * @param partInfo 零件
+     * @return 结果
+     */
+    @PostMapping("/deletePartInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String deleteVehicle(@RequestBody PartInfo partInfo) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到更新料箱信息请求：{}", JSON.toJSONString(partInfo));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (StringUtils.isEmpty(partInfo.getMaterial())) {// 零件号为空，不做处理
+                logger.error("请求删除的零件号为空");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("请求删除的零件号为空");
+                return JSON.toJSONString(rsp);
+            }
+            partInfoService.deletePartByPartNo(partInfo.getMaterial());
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("发生异常：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("删除零件信息成功");
+        return JSON.toJSONString(rsp);
+    }
+}

src/main/java/com/wms/controller/LocationController.java

@@ -0,0 +1,336 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.constants.enums.VehicleStatus;
+import com.wms.entity.app.LayerLocation;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.RowLocation;
+import com.wms.entity.page.PageDomain;
+import com.wms.entity.page.TableRequest;
+import com.wms.entity.page.TableResponse;
+import com.wms.entity.table.Location;
+import com.wms.entity.table.Vehicle;
+import com.wms.constants.WmsConstants;
+import com.wms.constants.enums.LocationStatus;
+import com.wms.service.LocationService;
+import com.wms.service.VehicleService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.StringUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+
+/**
+ * WMS库位控制类
+ *
+ * @author 梁州
+ * @date  2023/3/6
+ */
+@Controller
+@CrossOrigin
+@RequestMapping(value = "/wms/location")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class LocationController extends BaseController {
+    /**
+     * 库位服务
+     */
+    private final LocationService locationService;
+    /**
+     * 料箱服务
+     */
+    private final VehicleService vehicleService;
+    /**
+     * 请求头部信息
+     */
+    private final HttpServletRequest servletRequest;
+
+
+    /**
+     * 查询库位
+     *
+     * @param location 查询参数
+     * @return 结果
+     */
+    @PostMapping("/getLocations")
+    @ResponseBody
+    public String getLocations(@RequestBody Location location) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            // 查询出所有符合条件的库位
+            List<Location> locations = locationService.selLocations(location);
+            if (locations.size() < 1) {
+                logger.error("查询库位发生错误：库位不存在");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("查询库位发生错误：库位不存在");
+                return JSON.toJSONString(rsp);
+            }
+            List<RowLocation> rowLocations = new LinkedList<>();
+            // 查找到最大的排
+            locations.sort(Comparator.comparing(Location::getQueue).reversed());
+            int maxRow = locations.get(0).getQueue();
+            // 按排查找库位
+            for (int i = 0; i < maxRow; i++) {
+                int finalI = i;
+                List<Location> currentRowLocations = new ArrayList<>(locations.stream()
+                        .filter(l -> l.getQueue().equals(finalI + 1))
+                        .toList());
+                // 先查找每一层的库位
+                List<LayerLocation> layerLocations = new LinkedList<>();
+                // 找到这一排最大的层
+                currentRowLocations.sort(Comparator.comparing(Location::getLayer).reversed());
+                int maxLayer = currentRowLocations.get(0).getLayer();
+                // 按照每一列查找库位
+                for (int j = 0; j < maxLayer; j++) {
+                    int finalJ = j;
+                    List<Location> currentLayerLocations = currentRowLocations.stream()
+                            .filter(l -> l.getLayer().equals(finalJ + 1))
+                            .toList();
+                    LayerLocation tempLayerLocation = new LayerLocation();
+                    tempLayerLocation.setLayer(finalJ + 1);
+                    tempLayerLocation.setCurrentColLocations(currentLayerLocations);
+                    layerLocations.add(tempLayerLocation);
+                }
+                RowLocation tempRowLocation = new RowLocation();
+                tempRowLocation.setRow(finalI + 1);
+                tempRowLocation.setCurrentLayerLocations(layerLocations);
+                rowLocations.add(tempRowLocation);
+            }
+            logger.info("查询库位数据成功，库区：{}", location.getAreaId());
+            // 设置最终数据
+            rsp.setReturnData(rowLocations);
+            // 返回成功
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("查询库位成功");
+            return JSON.toJSONString(rsp);
+        } catch (Exception e) {
+            logger.info("查询库位发生错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+    }
+
+    /**
+     * 更新库位状态
+     *
+     * @param location 库位
+     * @return 结果
+     */
+    @PostMapping("/updateLocation")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateLocation(@RequestBody Location location) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            // TODO 这里要更新料箱信息
+            if (StringUtils.isNotEmpty(location.getVehicleId())) {// 载具号不为空
+                // 判断是不是需要往载具表里面添加数据
+                if (vehicleService.selVehicleById(location.getVehicleId()) == null) {
+                    // 添加新载具
+                    Vehicle newVehicle = new Vehicle();
+                    newVehicle.setVehicleId(location.getVehicleId());
+                    newVehicle.setVehicleStatus(VehicleStatus.ON.getCode());
+                    newVehicle.setCurrentLocation(location.getLocationId());
+                    newVehicle.setIsEmpty(1);
+                    vehicleService.addVehicle(newVehicle);
+                }
+            }
+            locationService.modifyLocation(location);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("更新库位状态发生错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("更新库位状态成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 更新库位状态
+     *
+     * @param location 库位
+     * @return 结果
+     */
+    @PostMapping("/getAvailableLocations")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String getAvailableLocations(@RequestBody Location location) {
+        logger.info("查询空闲可用库位");
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            Location locationQuery = new Location();
+            locationQuery.setAreaId(location.getAreaId());
+            locationQuery.setLocationStatus(LocationStatus.EMPTY.getCode());
+            locationQuery.setIsLock(0);
+            List<Location> availableLocations = locationService.selLocations(locationQuery);
+            rsp.setReturnData(availableLocations);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("查询可用库位错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("查询可用库位成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 查询料箱信息
+     * @param tableRequest 请求
+     * @return 结果
+     */
+    @PostMapping("/getVehicles")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String getVehicles(@RequestBody TableRequest<Vehicle, String> tableRequest) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到查询料箱请求：{}", JSON.toJSONString(tableRequest));
+        TableResponse tblResp = new TableResponse();
+        // 解析请求数据
+        if (tableRequest == null || tableRequest.getPage() == null) {
+            tblResp.setCode(ResponseCode.ERROR.getCode());
+            tblResp.setMessage("请求数据为空，无法处理！");
+            logger.error("请求数据为空，无法处理！");
+            return JSON.toJSONString(tblResp);
+        }
+        // 处理分页信息
+        PageDomain pageRequest = tableRequest.getPage();
+//        String[] orderByArr = {"task_id", "task_type", "task_status", "goods_id", "goods_name", "task_priority", "expiration_date", "create_time"};
+        String orderByStr = "";
+
+//        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
+//            orderByStr = pageRequest.getOrderBy();
+//        } else {
+//            // 默认排序
+//            orderByStr = "";
+//        }
+
+        Vehicle vehicleQuery = new Vehicle();
+        vehicleQuery.setVehicleId(tableRequest.getParam().getVehicleId());
+        PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
+        List<Vehicle> vehicles = vehicleService.selVehicles(vehicleQuery);
+        PageInfo<Vehicle> vehiclePageInfo = new PageInfo<>(vehicles);
+        tblResp.setCode(ResponseCode.OK.getCode());
+        tblResp.setMessage("查询料箱成功！");
+        tblResp.setRows(vehiclePageInfo.getList());
+        tblResp.setTotal(vehiclePageInfo.getTotal());
+        return JSON.toJSONString(tblResp);
+    }
+
+    /**
+     * 更新料箱信息
+     *
+     * @param vehicle 料箱
+     * @return 结果
+     */
+    @PostMapping("/updateVehicleInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateVehicleInfo(@RequestBody Vehicle vehicle) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到更新料箱信息请求：{}", JSON.toJSONString(vehicle));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (StringUtils.isEmpty(vehicle.getVehicleId())) {// 箱号为空，不执行
+                logger.error("请求箱号为空");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("请求箱号为空");
+                return JSON.toJSONString(rsp);
+            }
+            vehicleService.modifyVehicle(vehicle);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("发生异常：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("更新料箱信息成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 删除当前料箱信息
+     *
+     * @param vehicle 料箱
+     * @return 结果
+     */
+    @PostMapping("/deleteVehicle")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String deleteVehicle(@RequestBody Vehicle vehicle) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到更新料箱信息请求：{}", JSON.toJSONString(vehicle));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (StringUtils.isEmpty(vehicle.getVehicleId())) {// 箱号为空，不执行
+                logger.error("请求箱号为空");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("请求箱号为空");
+                return JSON.toJSONString(rsp);
+            }
+            // 判断当前料箱是不是空箱，带料不允许删除
+            Vehicle currentVehicle = vehicleService.selVehicleById(vehicle.getVehicleId());
+            if (currentVehicle != null && currentVehicle.getIsEmpty() != 1) {// 非空箱
+                logger.error("非空箱不允许删除");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("非空箱不允许删除");
+                return JSON.toJSONString(rsp);
+            }
+            // 将库中表中是当前载具的信息清空
+            Location locationQuery = new Location();
+            locationQuery.setVehicleId(vehicle.getVehicleId());
+            List<Location> locations = locationService.selLocations(locationQuery);
+            for (Location location : locations) {
+                location.setVehicleId(WmsConstants.EMPTY_STRING);
+                locationService.modifyLocation(location);
+            }
+            vehicleService.deleteVehicle(vehicle);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("发生异常：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("删除料箱成功");
+        return JSON.toJSONString(rsp);
+    }
+}

src/main/java/com/wms/controller/OrderCheckController.java

@@ -0,0 +1,62 @@
+package com.wms.controller;
+
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.dto.orderCheck.addOrderCheckRequest;
+import com.wms.entity.dto.orderCheck.queryOrderCheckRequest;
+import com.wms.entity.table.OrderCheck;
+import com.wms.service.IOrderCheckService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@Slf4j
+@RestController
+@CrossOrigin
+@RequestMapping(value = "/wms/api/orderCheck")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class OrderCheckController {
+
+
+    private final IOrderCheckService orderCheckService;
+
+    /**
+     * 查询订单
+     */
+    @PostMapping(value = "/queryOrderCheck")
+    public WmsApiResponse<List<OrderCheck>> getOrderCheck(@RequestBody queryOrderCheckRequest request) {
+        return orderCheckService.queryOrderCheck(request);
+    }
+
+    /**
+     * 执行订单
+     */
+    @PutMapping(value = "/executeOrderCheck/{recordId}") //更新
+    public WmsApiResponse<Object> executeOrderCheck(@PathVariable String recordId) {
+        return orderCheckService.executeOrderCheck(recordId);
+    }
+
+    /**
+     * 删除订单
+     */
+    @DeleteMapping(value = "/deleteCheck/{recordId}")
+    public WmsApiResponse<Object> deleteOrderIn(@PathVariable String recordId) {
+        return orderCheckService.deleteOrderCheck(recordId);
+    }
+
+    @DeleteMapping(value = "/deleteCheckAll/{remarkReturn}")
+    public WmsApiResponse<Object> deleteOrderInAll(@PathVariable String remarkReturn){
+        return orderCheckService.deleteOrderCheckAll(remarkReturn);
+    }
+
+
+    /**
+     * 添加订单
+     */
+    @PostMapping(value = "/addOrderCheck")
+    public WmsApiResponse<Object> addOrderCheck(@RequestBody addOrderCheckRequest request) {
+        return orderCheckService.addOrderCheck(request);
+    }
+}

src/main/java/com/wms/controller/OrderInController.java

@@ -0,0 +1,210 @@
+package com.wms.controller;
+
+import com.wms.controller.others.WcsController;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.wcs.RequireInRequest;
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.common.WmsApiResponseByCheckBack;
+import com.wms.entity.dto.orderIn.*;
+import com.wms.entity.table.*;
+import com.wms.mapper.*;
+import com.wms.service.IOrderInService;
+import jakarta.servlet.http.HttpSession;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+@Slf4j
+@RestController
+@CrossOrigin
+@RequestMapping(value = "/wms/api/orderIn")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class OrderInController {
+
+    private final WcsController wcsController;
+    private  final AppOrderInMapper appOrderInMapper;
+    private  final VehicleIistMapper vehicleIistMapper;
+    private final PartInfoMapper partInfoMapper;
+    private final IOrderInService iOrderInService;
+    private final TaskMapper taskMapper;
+
+
+    /**
+     * 查询入库单
+     * @param request 请求参数
+     * @return 返回结果
+     */
+    @PostMapping(value = "/queryOrderIn")
+    public WmsApiResponse<List<AppOrderIn>> queryOrderIn(@RequestBody queryOrderInRequest request) {
+        return iOrderInService.queryOrderIn(request);
+    }
+
+    /**
+     * 发动机应急申请入库
+     * @param request 请求参数
+     * @return 返回结果
+     */
+    @PostMapping(value = "/loginInBad")
+    public ResponseEntity loginInBad(@RequestBody loginInBad request) {
+        //对入库口、母托号、机型进行判断
+        if (request.getEfSelect() == null || request.getEfSelect().isEmpty()){
+            return new ResponseEntity(-1, "入库口不能为空，请重试！");
+        }
+        if (request.getVehicleNo()== null || request.getVehicleNo().isEmpty()){
+            return new ResponseEntity(-1, "母托号不能为空，请重试！");
+        }
+        if (request.getModel() == null || request.getModel().isEmpty()){
+            return new ResponseEntity(-1, "机型不能为空，请重试！");
+        }
+        if (!"201".equals(request.getEfSelect()) && !"228".equals(request.getEfSelect())) {
+            return new ResponseEntity(-1, "入库口填写错误，请重试！");
+        }
+        VechileList vehicle = new VechileList();
+        vehicle.setVehicleId(request.getVehicleNo());
+        if (vehicleIistMapper.select(vehicle) == null || vehicleIistMapper.select(vehicle).isEmpty()){
+            return new ResponseEntity(-1, "该母托号在数据库中不存在！");
+        }
+        //检查机型
+        PartInfo partInfo = new PartInfo();
+        partInfo.setMaterial(request.getModel());
+        partInfo.setItemDesc("发动机");
+        if (partInfoMapper.selPartsByEqual(partInfo) == null || partInfoMapper.selPartsByEqual(partInfo).isEmpty()){
+            return new ResponseEntity(-1, "该机型在数据库中不存在！");
+        }
+        RequireInRequest requestForUse = new RequireInRequest();
+        requestForUse.setPoint(request.getEfSelect());
+        requestForUse.setVehicleNo(request.getVehicleNo());
+        requestForUse.setModel(request.getModel());
+        requestForUse.setCodeMessage(request.getGoodsId());
+        return wcsController.requestIn(requestForUse);
+    }
+
+    /**
+     * 解析条码创建入库单
+     * @param request 请求参数
+     * @return 返回结果
+     */
+    @PostMapping(value = "/bindingVehicl")
+    @ResponseBody
+    public WmsApiResponse<Object> addOrderInByBlinging(@RequestBody downOrderInRequest request) {
+        String[] parts = request.goodsId.split("&");
+        if (parts.length != 3){
+            return new WmsApiResponse<>(-1, "条码格式错误，正确格式：物料号&数量&日期（例：PK100001&100&20250101）",null);
+        }
+        //检查原材料
+        PartInfo partInfo = new PartInfo();
+        partInfo.setMaterial(parts[0]);
+        partInfo.setItemDesc("原材料");
+        if (partInfoMapper.selPartsByEqual(partInfo) == null || partInfoMapper.selPartsByEqual(partInfo).isEmpty()){
+            return new WmsApiResponse<>(-1, "该原材料条码的物料号在数据库中不存在",null);
+        }
+        //检查母托盘
+        VechileList vehicle = new VechileList();
+        vehicle.setVehicleId(request.getVehicleNo());
+        if (vehicleIistMapper.select(vehicle) == null || vehicleIistMapper.select(vehicle).isEmpty()){
+            return new WmsApiResponse<>(-1, "该母托盘在数据库中不存在",null);
+        }
+        if(parts[2].length() != 8){
+            return new WmsApiResponse<>(-1, "条码最后日期格式错误，正确格式例如：20250101",null);
+        }
+        return iOrderInService.addOrderInByBlinging(request, request.getUserName());
+    }
+
+    /**
+     * 绑定载具
+     * @param request 请求参数
+     * @return 返回结果
+     */
+    @PostMapping(value = "/bindingVehicle")
+    public WmsApiResponse<Object> bindingVehicle(@RequestBody bindingVehicleRequest request) {
+        return iOrderInService.bindingVehicle(request);
+    }
+
+    /**
+     * 更新数量
+     * @return 更新结果
+     */
+    @PostMapping(value = "/updateForNum")
+    public WmsApiResponse<Object> updateForNum(@RequestBody updateNumRequest request) {
+        return iOrderInService.updateForNum(request);
+    }
+
+    /**
+     * 更新数据
+     * @return 更新结果
+     */
+    @PostMapping(value = "/updateForInformation")
+    public WmsApiResponse<Object> updateForInformation(@RequestBody updateInformation request) {
+        return iOrderInService.updateForInformation(request);
+    }
+
+
+    /**
+     * 根据载具号查询入库单
+     * @param vehicleNo 载具号
+     * @return 查询结果
+     */
+    @GetMapping(value = "/getOrderInWithVehicleNo")
+    public WmsApiResponseByCheckBack<List<AppOrderIn>> getOrderInWithVehicleNo(@RequestParam("vehicleNo") String vehicleNo) {
+        return iOrderInService.getOrderInWithVehicleNo(vehicleNo);
+    }
+
+    /**
+     * 解绑载具
+     * @param rowId 行号
+     * @return 解绑结果
+     */
+    @PutMapping(value = "/unBindingVehicle/{rowId}")
+    public WmsApiResponse<Object> unBindingVehicle(@PathVariable String rowId) {
+        return iOrderInService.unBindingVehicle(rowId);
+    }
+
+    /**
+     * 新增入库单
+     * @param request 请求参数
+     * @return 返回结果
+     */
+    @PostMapping(value = "/addOrderIn")
+    public WmsApiResponse<Object> addOrderIn(@RequestBody downOrderInRequest request) {
+        return iOrderInService.addOrderIn(request);
+    }
+
+    /**
+     * 删除入库单
+     * @param rowId 行号
+     * @return 删除结果
+     */
+    @DeleteMapping(value = "/deleteOrderIn/{rowId}")
+    public WmsApiResponse<Object> deleteOrderIn(@PathVariable String rowId) {
+        return iOrderInService.deleteOrderIn(rowId);
+    }
+
+    /**
+     * 将入库单转化成入库任务，要求支持单箱和并箱
+     * @return 返回结果
+     */
+    @PostMapping(value = "/addInByTask")
+    public ResponseEntity addInByTask(@RequestBody goodsInByTaskRequest request) {
+        List<AppOrderIn> check = appOrderInMapper.selectWithVehicle(request.getVehicleNo());
+        if (check == null || check.isEmpty()){
+            return new ResponseEntity(400, "该母托号没有任务，请先绑定");
+        }
+        Task task = new Task();
+        task.setVehicleNo(request.getVehicleNo());
+        if (taskMapper.selTasks(task) == null || taskMapper.selTasks(task).isEmpty()){
+            //return iOrderInService.addInByTask(request);
+            RequireInRequest requestForUse = new RequireInRequest();
+            requestForUse.setPoint(request.getSelectByIn());
+            requestForUse.setVehicleNo(request.getVehicleNo());
+            requestForUse.setModel(null);
+            requestForUse.setCodeMessage("YJRK0001&00100&10001215");
+            return wcsController.requestIn(requestForUse);
+        }
+        return new ResponseEntity(400, "该母托号已下发任务，请勿重复下发");
+    }
+}

src/main/java/com/wms/controller/OrderOutController.java

@@ -0,0 +1,174 @@
+package com.wms.controller;
+
+
+import com.wms.constants.enums.OrderOutStatusEnum;
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.dto.orderOut.handOrderOutRequest;
+import com.wms.entity.dto.orderOut.queryOrderOutRequest;
+import com.wms.entity.table.OrderOut;
+import com.wms.entity.table.Stock;
+import com.wms.mapper.OrderOutMapper;
+import com.wms.mapper.OrderOutRecordMapper;
+import com.wms.service.IOrderOutService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@Slf4j
+@RestController
+@CrossOrigin
+@RequestMapping(value = "/wms/api/orderOut")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class OrderOutController {
+
+    private final OrderOutMapper orderOutMapper;
+    private final OrderOutRecordMapper orderOutRecordMapper;
+    private final IOrderOutService orderOutService;
+
+    /**
+     * 查询出库单
+     * @param request 请求参数
+     * @return 结果
+     */
+    @PostMapping(value = "/queryOrderOut")  //刪除
+    public WmsApiResponse<List<OrderOut>> queryOrderOut(@RequestBody queryOrderOutRequest request) {
+        return orderOutService.queryOrderOut(request);
+    }
+
+    /**
+     * 查询按库位出库的出库单
+     * @param request 请求参数
+     * @return 结果
+     */
+    @PostMapping(value = "/queryOrderOutByLocation")  //刪除
+    public WmsApiResponse<List<OrderOut>> queryOrderOutByLocation(@RequestBody queryOrderOutRequest request) {
+        return orderOutService.queryOrderOutByLocation(request);
+    }
+
+    /**
+     * 手动把出库单变成完成
+     * @param rowId 请求参数
+     * @return 结果
+     */
+    @PutMapping(value = "/handFinish/{rowId}")
+    public WmsApiResponse<Object> handFinish(@PathVariable String rowId) {
+        return orderOutService.handFinish(rowId);
+    }
+    /**
+     * 执行出库单
+     * @param rowId 数据行号
+     * @return 执行结果
+     */
+    @PutMapping(value = "/executeOrderOut/{rowId}") //更新
+    public WmsApiResponse<Object> executeOrderOut(@PathVariable String rowId) {
+        return orderOutService.executeOrderOut(rowId);
+    }
+
+    /**
+     * 生成出库任务
+     * @return 执行结果
+     */
+    @PutMapping(value = "/downCheckTask") //更新
+    public WmsApiResponse<Object> downCheckTask(@RequestBody Stock stock) {
+        return orderOutService.downCheckTask(stock);
+    }
+
+    /**
+     * 按库位出库
+     */
+    @PutMapping(value = "/executeOrderOutByLocation/{rowId}")
+    public WmsApiResponse<Object> executeOrderOutByLocation(@PathVariable String rowId) {
+        return orderOutService.executeOrderOutByLocation(rowId);
+    }
+
+    /**
+     * 完成出库工单
+     * @return 结果
+     */
+    @PostMapping(value = "/finishTaskFile")
+    public WmsApiResponse<Object> finishTaskFile() {
+        //把所有订单类型为1的出库单备份一下再删除，先检查是否全部完成
+        OrderOut orderOut0 = new OrderOut();
+        orderOut0.setOrderType(1);
+        List<OrderOut> queryResult = orderOutMapper.query(orderOut0);
+
+        List<OrderOut> filteredOrderOuts = queryResult.stream()
+                .filter(orderOut -> orderOut.getStatus() != 100)
+                .toList();
+
+        if (!filteredOrderOuts.isEmpty()){
+            return new WmsApiResponse<>(1, "还有未完成的出库单，请先完成", null);
+        }
+        if (orderOutRecordMapper.insertList(queryResult) > 0){
+            //删除所有订单类型为1的出库单
+            orderOutMapper.deleteOrdersByType(1);
+            return new WmsApiResponse<>(0, "执行成功", null);
+        }
+        return new WmsApiResponse<>(1, "执行失败，备份失败", null);
+    }
+
+    /**
+     * 母托下线
+     * @return 执行结果
+     */
+    @PutMapping(value = "/downEmptyBox") //更新
+    public WmsApiResponse<Object> downEmptyBox() {
+        return orderOutService.executeDownEmpty();
+    }
+
+    /**
+     * 一键执行所有出库单
+     * @return 执行结果
+     */
+    @PutMapping(value = "/executeAllOrderOut/{rowId}")
+    public WmsApiResponse<Object> outAllOrderOut() {
+        List<OrderOut> queryResult = orderOutMapper.queryAll();
+
+        List<OrderOut> filteredOrderOuts = queryResult.stream()
+                .filter(orderOut -> (orderOut.getOrderType() == 1 || orderOut.getOrderType() == 2) && orderOut.getStatus() != 100 && orderOut.getStatus() != 1)
+                .toList();
+
+        boolean allSuccess = true;
+        for (OrderOut row : filteredOrderOuts) {
+            String rowId2 = row.getRowId();
+            try {
+                WmsApiResponse<Object> a = orderOutService.executeOrderOut(rowId2);
+                log.info("执行出库单 {}: {}", rowId2, a);
+            } catch (Exception e) {
+                log.error("执行出库单 {} 失败: {}", rowId2, e.getMessage());
+                allSuccess = false;
+            }
+        }
+
+        if (allSuccess) {
+            return new WmsApiResponse<>(0, "执行成功", null);
+        } else {
+            return new WmsApiResponse<>(1, "部分出库单执行失败，请检查日志", null);
+        }
+    }
+
+
+    /**
+     * 删除出库单
+     * @param rowId 数据行号
+     * @return 删除结果
+     */
+    @DeleteMapping(value = "/deleteOrderOut/{rowId}") //刪除
+    public WmsApiResponse<Object> deleteOrderOut(@PathVariable String rowId) {
+        return orderOutService.deleteOrderOut(rowId);
+    }
+
+
+    /**
+     * 创建手动出库单
+     * @return 创建结果
+     */
+    @PostMapping(value = "/addOrderOut")
+    public WmsApiResponse<Object> createOrderOut(@RequestBody handOrderOutRequest request) {
+        return orderOutService.createOrderOut(request);
+    }
+
+}

src/main/java/com/wms/controller/RecordController.java

@@ -0,0 +1,91 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.entity.page.PageDomain;
+import com.wms.entity.page.TableRequest;
+import com.wms.entity.page.TableResponse;
+import com.wms.entity.table.Task;
+import com.wms.mapper.TaskRecordMapper;
+import com.wms.service.TaskRecordService;
+import com.wms.utils.HttpUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * WMS记录控制类
+ *
+ * @author 梁州
+ * @date 2023/2/14
+ */
+@Controller
+@CrossOrigin
+@RequestMapping(value = "/wms/record")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class RecordController extends BaseController {
+    /**
+     * 任务记录服务
+     */
+    private final TaskRecordService taskRecordService;
+    /**
+     * 请求头部信息
+     */
+    private final HttpServletRequest servletRequest;
+    private final TaskRecordMapper taskRecordMapper;
+    /**
+     * 查询任务记录
+     *
+     * @param tableRequest 请求
+     * @return 结果
+     */
+    @PostMapping("/getTaskRecords")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String getVehicles(@RequestBody TableRequest<Task, String> tableRequest) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到查询任务记录请求：{}", JSON.toJSONString(tableRequest));
+        TableResponse tblResp = new TableResponse();
+        // 解析请求数据
+        if (tableRequest == null || tableRequest.getPage() == null) {
+            tblResp.setCode(ResponseCode.ERROR.getCode());
+            tblResp.setMessage("请求数据为空，无法处理！");
+            logger.error("请求数据为空，无法处理！");
+            return JSON.toJSONString(tblResp);
+        }
+        // 处理分页信息
+//        PageDomain pageRequest = tableRequest.getPage();
+////        String[] orderByArr = {"task_id", "task_type", "task_status", "goods_id", "goods_name", "task_priority", "expiration_date", "create_time"};
+//        String orderByStr = "";
+
+//        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
+//            orderByStr = pageRequest.getOrderBy();
+//        } else {
+//            // 默认排序
+//            orderByStr = "";
+//        }
+
+        Task taskRecordQuery = new Task();
+        taskRecordQuery.setTaskType(tableRequest.getParam().getTaskType());
+        taskRecordQuery.setGoodsId(tableRequest.getParam().getGoodsId());
+        taskRecordQuery.setVehicleNo(tableRequest.getParam().getVehicleNo());
+    //    PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
+        List<Task> records = taskRecordMapper.selTasks(taskRecordQuery);
+        PageInfo<Task> taskRecordPageInfo = new PageInfo<>(records);
+        tblResp.setCode(ResponseCode.OK.getCode());
+        tblResp.setMessage("查询任务记录成功！");
+        tblResp.setRows(taskRecordPageInfo.getList());
+        tblResp.setTotal(taskRecordPageInfo.getTotal());
+        return JSON.toJSONString(tblResp);
+
+    }
+}

src/main/java/com/wms/controller/StandController.java

@@ -0,0 +1,133 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.page.PageDomain;
+import com.wms.entity.page.TableRequest;
+import com.wms.entity.page.TableResponse;
+import com.wms.entity.table.Stand;
+import com.wms.service.StandService;
+import com.wms.utils.HttpUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 站台控制类
+ */
+@Controller
+@CrossOrigin
+@RequestMapping(value = "/wms/stand")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class StandController extends BaseController {
+    /**
+     * 站台服务
+     */
+    private final StandService standService;
+    /**
+     * 请求头部信息
+     */
+    private final HttpServletRequest servletRequest;
+
+    /**
+     * 查询可用站台列表
+     * @return 符合条件的站台列表
+     */
+    @PostMapping("/getAllStands")
+    @ResponseBody
+    public List<Stand> getAllStands(@RequestBody JSONObject type){
+        logger.info("查询站台{}", JSON.toJSONString(type));
+        int type_int = type.getIntValue("type");
+        Stand query = new Stand();
+        if (type_int == 1) {// 入库站台
+            query.setAllowIn(1);
+        } else if (type_int == 2) {// 出库站台
+            query.setAllowOut(1);
+        } else if (type_int == 3) {// 盘点站台
+            query.setAllowIn(1);
+            query.setAllowOut(1);
+        }
+        return standService.selStands(query);
+    }
+
+    /**
+     * 更新站台状态
+     *
+     * @param stand 站台
+     * @return 结果
+     */
+    @PostMapping("/updateStandInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateStandInfo(@RequestBody Stand stand) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            standService.modifyStand(stand);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("更新站台信息发生错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        logger.info("更新站台信息成功：{}", stand.toLoggerString());
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("更新站台信息成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 查找所有库存
+     */
+    @PostMapping("/getStands")
+    @ResponseBody
+    public String getStands(@RequestBody TableRequest<Stand, String> tableRequest){
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到查询库存请求：{}", JSON.toJSONString(tableRequest));
+        TableResponse tblResp = new TableResponse();
+        // 解析请求数据
+        if (tableRequest == null || tableRequest.getPage() == null) {
+            tblResp.setCode(ResponseCode.ERROR.getCode());
+            tblResp.setMessage("请求数据为空，无法处理！");
+            logger.error("请求数据为空，无法处理！");
+            return JSON.toJSONString(tblResp);
+        }
+        // 处理分页信息
+        PageDomain pageRequest = tableRequest.getPage();
+//        String[] orderByArr = {"location_id", "vehicle_id", "goods_id", "batch_no", "remain_num", "expiration_date", "create_time"};
+        String orderByStr = "";
+
+//        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
+//            orderByStr = pageRequest.getOrderBy();
+//        } else {
+//            // 默认排序
+//            orderByStr = "expiration_date desc";
+//        }
+
+        PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
+        List<Stand> stands = standService.selStands(tableRequest.getParam());
+        PageInfo<Stand> standPageInfo = new PageInfo<>(stands);
+        tblResp.setCode(ResponseCode.OK.getCode());
+        tblResp.setMessage("查询库存成功！");
+        tblResp.setRows(standPageInfo.getList());
+        tblResp.setTotal(standPageInfo.getTotal());
+        logger.info("查询库存成功，总数：{}，当前页：{}，当前页数量：{}", standPageInfo.getTotal(), standPageInfo.getPageNum(), standPageInfo.getPageSize());
+        return JSON.toJSONString(tblResp);
+    }
+}

src/main/java/com/wms/controller/StockController.java

@@ -0,0 +1,285 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.page.PageDomain;
+import com.wms.entity.page.TableRequest;
+import com.wms.entity.page.TableResponse;
+import com.wms.entity.table.OrderOut;
+import com.wms.entity.table.Stock;
+import com.wms.service.StockService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.StringUtils;
+import com.wms.utils.WmsUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * WMS库存控制类
+ * @author 梁州
+ * @date  2023/2/14
+ */
+@Controller
+@CrossOrigin
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+@RequestMapping(value = "/wms/stock")
+public class StockController extends BaseController {
+    /**
+     * 库存服务
+     */
+    private final StockService stockService;
+
+    /**
+     * 请求头部信息
+     */
+    private final HttpServletRequest servletRequest;
+
+    /**
+     * 查找所有库存
+     */
+    @PostMapping("/getAllStocks")
+    @ResponseBody
+    public String getAllStocks(@RequestBody TableRequest<String, String> tableRequest){
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到查询库存请求：{}", JSON.toJSONString(tableRequest));
+        TableResponse tblResp = new TableResponse();
+        // 解析请求数据
+        if (tableRequest == null || tableRequest.getPage() == null) {
+            tblResp.setCode(ResponseCode.ERROR.getCode());
+            tblResp.setMessage("请求数据为空，无法处理！");
+            logger.error("请求数据为空，无法处理！");
+            return JSON.toJSONString(tblResp);
+        }
+        // 处理分页信息
+        PageDomain pageRequest = tableRequest.getPage();
+        String[] orderByArr = {"location_id", "vehicle_id", "goods_id", "batch_no", "remain_num", "expiration_date", "create_time"};
+        String orderByStr;
+
+        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
+            orderByStr = pageRequest.getOrderBy();
+        } else {
+            // 默认排序
+            orderByStr = "expiration_date desc";
+        }
+
+        PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
+        //List<Stock> stocks = stockService.selStocksFront(tableRequest.getParam());
+        List<Stock> stocks = stockService.selStocksFrontTwo(tableRequest.getParam(), tableRequest.getParam2());
+        PageInfo<Stock> stockPageInfo = new PageInfo<>(stocks);
+        tblResp.setCode(ResponseCode.OK.getCode());
+        tblResp.setMessage("查询库存成功！");
+        tblResp.setRows(stockPageInfo.getList());
+        tblResp.setTotal(stockPageInfo.getTotal());
+        logger.info("查询库存成功，总数：{}，当前页：{}，当前页数量：{}", stockPageInfo.getTotal(), stockPageInfo.getPageNum(), stockPageInfo.getPageSize());
+        return JSON.toJSONString(tblResp);
+    }
+
+    /**
+     * 查找所有原材料
+     */
+    @PostMapping("/getAllStocks1")
+    @ResponseBody
+    public String getAllStocksByY(@RequestBody TableRequest<String, String> tableRequest){
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到查询库存请求：{}", JSON.toJSONString(tableRequest));
+        TableResponse tblResp = new TableResponse();
+        // 解析请求数据
+        if (tableRequest == null || tableRequest.getPage() == null) {
+            tblResp.setCode(ResponseCode.ERROR.getCode());
+            tblResp.setMessage("请求数据为空，无法处理！");
+            logger.error("请求数据为空，无法处理！");
+            return JSON.toJSONString(tblResp);
+        }
+        // 处理分页信息
+        PageDomain pageRequest = tableRequest.getPage();
+        String[] orderByArr = {"location_id", "vehicle_id", "goods_id", "batch_no", "remain_num", "expiration_date", "create_time"};
+        String orderByStr;
+
+        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
+            orderByStr = pageRequest.getOrderBy();
+        } else {
+            // 默认排序
+            orderByStr = "expiration_date desc";
+        }
+
+        PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
+        //List<Stock> stocks = stockService.selStocksFront(tableRequest.getParam());
+        List<Stock> stocks1 = stockService.selStocksFrontTwo(tableRequest.getParam(), tableRequest.getParam2());
+
+        // 过滤掉所有 batchNo 不是原材料的库存记录
+        List<Stock> stocks = stocks1.stream()
+                .filter(stock -> {
+                    String batchNo = stock.getBatchNo();
+                    return batchNo != null && batchNo.equals("原材料");
+                })
+                .toList();
+
+
+
+        PageInfo<Stock> stockPageInfo = new PageInfo<>(stocks);
+        tblResp.setCode(ResponseCode.OK.getCode());
+        tblResp.setMessage("查询库存成功！");
+        tblResp.setRows(stockPageInfo.getList());
+        tblResp.setTotal(stockPageInfo.getTotal());
+        logger.info("查询库存成功，总数：{}，当前页：{}，当前页数量：{}", stockPageInfo.getTotal(), stockPageInfo.getPageNum(), stockPageInfo.getPageSize());
+        return JSON.toJSONString(tblResp);
+    }
+
+    /**
+     * 批量查找符合条件的库存---按物料汇总
+     */
+    @PostMapping("/getAllStocksByMultiple")
+    @ResponseBody
+    public String getAllStocksByMultiple(@RequestBody String[] multiQueryEntries){
+        TableResponse rsp = new TableResponse();
+        if (multiQueryEntries == null){
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("请求数据为空，无法处理！");
+            return JSON.toJSONString(rsp);
+        }
+        List<Stock> stocksByAllKeys = new ArrayList<>();
+        for(String multiQueryEntry : multiQueryEntries){
+            //去查询符合条件的数据并插入到一个表中
+            Stock stock = new Stock();
+            stock.setGoodsId(multiQueryEntry);
+            List<Stock> stocks = stockService.selStocks(stock);
+            //把stocks全部添加到stocksByAllKeys中
+            stocksByAllKeys.addAll(stocks);
+        }
+        PageInfo<Stock> stockPageInfo = new PageInfo<>(stocksByAllKeys);
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("查询库存成功！");
+        rsp.setRows(stockPageInfo.getList());
+        rsp.setTotal(stockPageInfo.getTotal());
+        return JSON.toJSONString(rsp);
+    }
+    /**
+     * 查找所有库存---按物料汇总
+     */
+    @PostMapping("/getAllStocksByGoodsId")
+    @ResponseBody
+    public String getAllStocksByGoodsId(@RequestBody TableRequest<String, String> tableRequest){
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到查询库存请求：{}", JSON.toJSONString(tableRequest));
+        TableResponse tblResp = new TableResponse();
+        // 解析请求数据
+        if (tableRequest == null || tableRequest.getPage() == null) {
+            tblResp.setCode(ResponseCode.ERROR.getCode());
+            tblResp.setMessage("请求数据为空，无法处理！");
+            logger.error("请求数据为空，无法处理！");
+            return JSON.toJSONString(tblResp);
+        }
+        // 处理分页信息
+        PageDomain pageRequest = tableRequest.getPage();
+        String[] orderByArr = {"location_id", "vehicle_id", "goods_id", "batch_no", "remain_num", "expiration_date", "create_time"};
+        String orderByStr;
+
+        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
+            orderByStr = pageRequest.getOrderBy();
+        } else {
+            // 默认排序
+            orderByStr = "goods_id desc";
+        }
+        Stock stockQuery = new Stock();
+        stockQuery.setGoodsId(tableRequest.getParam());
+        PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
+        List<Stock> stocks = stockService.selStocksByGoodsId(stockQuery);
+        PageInfo<Stock> stockPageInfo = new PageInfo<>(stocks);
+        tblResp.setCode(ResponseCode.OK.getCode());
+        tblResp.setMessage("查询库存成功！");
+        tblResp.setRows(stockPageInfo.getList());
+        tblResp.setTotal(stockPageInfo.getTotal());
+        logger.info("查询库存成功，总数：{}，当前页：{}，当前页数量：{}", stockPageInfo.getTotal(), stockPageInfo.getPageNum(), stockPageInfo.getPageSize());
+        return JSON.toJSONString(tblResp);
+    }
+
+    /**
+     * 更新库存信息
+     *
+     * @param stock 库存
+     * @return 结果
+     */
+    @PostMapping("/updateStockInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateStockInfo(@RequestBody Stock stock) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到更新库存信息请求：{}", JSON.toJSONString(stock));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (StringUtils.isEmpty(stock.getStockId())) {// 库存编号为空，不允许执行
+                logger.error("请求的库存编号为空，不允许修改");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("请求的库存编号为空，不允许修改");
+                return JSON.toJSONString(rsp);
+            }
+            if (stock.getRealNum() == 0) {
+                stockService.deleteStock(stock.getStockId());
+            } else {
+                stockService.modifyStock(stock);
+            }
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("发生异常：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("更新库存信息成功");
+        return JSON.toJSONString(rsp);
+    }
+
+    /**
+     * 新增库存
+     *
+     * @param stock 库存
+     * @return 结果
+     */
+    @PostMapping("/addNewStock")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String addNewStock(@RequestBody Stock stock) {
+        logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
+        logger.info("接收到人工添加库存：{}", JSON.toJSONString(stock));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            Stock tempStock = new Stock();
+            tempStock.setStockId(WmsUtils.generateId("ST"));
+
+
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("发生异常：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+        // 返回成功
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("添加库存信息成功");
+        return JSON.toJSONString(rsp);
+    }
+}

src/main/java/com/wms/controller/TaskDealController.java

@@ -0,0 +1,339 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.wms.constants.enums.*;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.table.Location;
+import com.wms.entity.app.wcs.WmsReceiveTaskResultEntity;
+import com.wms.entity.table.Stock;
+import com.wms.entity.table.Task;
+import com.wms.service.LocationService;
+import com.wms.service.StockService;
+import com.wms.service.TaskService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.StringUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 这个类处理任务反馈信息
+ */
+@Controller
+@CrossOrigin
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+@RequestMapping(value = "/wms/taskDeal")
+public class TaskDealController extends BaseController{
+    private final TaskService taskService;
+    private final HttpServletRequest servletRequest;
+    private final TaskController taskController;
+    private final StockService stockService;
+    private final LocationService locationService;
+
+
+//    /**
+//     * 更改任务状态
+//     */
+//    @PostMapping("/changeTaskStatus")
+//    @ResponseBody
+//    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+//    public String changeTaskStatus(@RequestBody Task request) {
+//        logger.info("用户请求更改任务状态，用户名：{}，ip地址：{}", request.getUserName(), HttpUtils.getIpAddr(servletRequest));
+//        ResponseEntity rsp = new ResponseEntity();
+//        try {
+//            if (request.getTaskStatus() == null) {
+//                logger.error("任务状态为空");
+//                rsp.setCode(ResponseCode.ERROR.getCode());
+//                rsp.setMessage("请选择任务状态");
+//                return JSON.toJSONString(rsp);
+//            }
+//            // 更改后的任务状态
+//            int taskStatusRequest = request.getTaskStatus();
+//            // 查询任务
+//            Task taskQuery = new Task();
+//            taskQuery.setTaskId(request.getTaskId());
+//            List<Task> tasks = taskService.selTasks(taskQuery);
+//            if (tasks.isEmpty()) {
+//                logger.error("当前任务不存在");
+//                rsp.setCode(ResponseCode.ERROR.getCode());
+//                rsp.setMessage("当前任务不存在");
+//                return JSON.toJSONString(rsp);
+//            }
+//            Task currentTask = tasks.get(0);
+//            if (taskStatusRequest == 1) {// 取消任务
+//                logger.info("任务取消");
+//                WmsReceiveTaskResultEntity sendToWmsRequest = new WmsReceiveTaskResultEntity();
+//                sendToWmsRequest.setTaskId(taskGroupId);
+//                sendToWmsRequest.setTaskStatus(WcsTaskStatus.CANCEL.getCode());
+//                sendToWmsRequest.setVehicleNo(currentTask.getVehicleNo());
+//                sendToWmsRequest.setDestination(currentTask.getDestination());
+//                taskController.receiveTaskResult(sendToWmsRequest);
+//                wcsTaskStatusAfter = 999;
+//            }
+//
+//        }catch (Exception e) {
+//            // 回滚事务
+//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+//            logger.error("发生异常{}", e.getMessage());
+//            rsp.setCode(ResponseCode.ERROR.getCode());
+//            rsp.setMessage("发生异常" + e.getMessage());
+//            return JSON.toJSONString(rsp);
+//        }
+//    }
+
+    /**
+     * 更改任务状态
+     *
+     * @param request 请求参数
+     * @return 结果
+     */
+    @PostMapping("/changeTaskStatus")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String changeTaskStatus(@RequestBody Task request) {
+        //logger.info("用户请求更改任务状态，用户名：{}，ip地址：{}", request.getUserName(), HttpUtils.getIpAddr(servletRequest));
+        logger.info("请求详细：{}", JSON.toJSONString(request));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            if (request.getTaskStatus() == null) {
+                logger.error("请选择任务状态");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("请选择任务状态");
+                return JSON.toJSONString(response);
+            }
+            // 更改后的任务状态
+            int taskStatusRequest = request.getTaskStatus();
+            int wcsTaskStatusAfter = 0;
+            // 查询任务
+            Task taskQuery = new Task();
+            taskQuery.setTaskId(request.getTaskId());
+            List<Task> tasks = taskService.selTasks(taskQuery);
+            if (tasks.size() == 0) {
+                logger.error("当前任务不存在");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("当前任务不存在");
+                return JSON.toJSONString(response);
+            }
+            Task currentTask = tasks.get(0);
+            String newDestination = "";
+            if (Objects.equals(currentTask.getTaskType(), TaskType.IN.getCode()) && StringUtils.isNotEmpty(request.getDestination()) && !Objects.equals(request.getDestination(), currentTask.getDestination())) {// 入库任务库位变更
+                if (taskStatusRequest != 0) {
+                    logger.error("更改库位必须重置任务");
+                    response.setCode(ResponseCode.ERROR.getCode());
+                    response.setMessage("更改库位必须重置任务");
+                    return JSON.toJSONString(response);
+                }
+                newDestination = request.getDestination();
+            }
+            if (currentTask.getTaskId().startsWith("HK") && taskStatusRequest == 1) {
+                logger.error("回库任务不允许取消");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("回库任务不允许取消");
+                return JSON.toJSONString(response);
+            }
+            String taskGroupId = currentTask.getTaskGroup();
+            if (taskStatusRequest == 0) {// 重置任务
+                logger.info("任务重置");
+                // 将当前taskGroup的所有任务都设置为新建状态
+                Task taskQuery2 = new Task();
+                taskQuery2.setTaskGroup(taskGroupId);
+                List<Task> tasks2 = taskService.selTasks(taskQuery2);
+                for (Task task2 : tasks2) {
+                    if (StringUtils.isNotEmpty(newDestination)) {
+                        task2.setDestination(newDestination);
+                    }
+                    task2.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                    task2.setUserName(request.getUserName());
+                    taskService.executeTask(task2);
+                }
+                // 如果更新了任务，那么该库位信息也要变更
+                if (Objects.equals(currentTask.getTaskType(), TaskType.IN.getCode()) && StringUtils.isNotEmpty(newDestination)) {
+                    Location newLocationQuery = new Location(newDestination);
+                    List<Location> newLocations = locationService.selLocations(newLocationQuery);
+                    for (Location newLocation : newLocations) {
+                        newLocation.setVehicleId(currentTask.getVehicleNo());
+                        newLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+                        locationService.modifyLocation(newLocation);
+                        break;
+                    }
+                }
+                // WCS取消任务
+            } else if (taskStatusRequest == 1) {// 取消任务
+                logger.info("任务取消");
+                WmsReceiveTaskResultEntity sendToWmsRequest = new WmsReceiveTaskResultEntity();
+                sendToWmsRequest.setTaskId(taskGroupId);
+                sendToWmsRequest.setTaskStatus(WcsTaskStatus.CANCEL.getCode());
+                sendToWmsRequest.setVehicleNo(currentTask.getVehicleNo());
+                sendToWmsRequest.setDestination(currentTask.getDestination());
+                taskController.receiveTaskResult(sendToWmsRequest);
+                wcsTaskStatusAfter = 999;
+            } else if (taskStatusRequest == 2) {// 完成任务
+                logger.info("任务完成");
+                WmsReceiveTaskResultEntity sendToWmsRequest = new WmsReceiveTaskResultEntity();
+                sendToWmsRequest.setTaskId(taskGroupId);
+                sendToWmsRequest.setTaskStatus(WcsTaskStatus.FINISH.getCode());
+                sendToWmsRequest.setVehicleNo(currentTask.getVehicleNo());
+                sendToWmsRequest.setDestination(currentTask.getDestination());
+                taskController.receiveTaskResult(sendToWmsRequest);
+                wcsTaskStatusAfter = 3;
+            }
+            // 向WCS反馈
+            WmsReceiveTaskResultEntity sendToWcsRequest = new WmsReceiveTaskResultEntity();
+            sendToWcsRequest.setTaskId(taskGroupId);
+            sendToWcsRequest.setTaskStatus(wcsTaskStatusAfter);
+            if (StringUtils.isNotEmpty(newDestination)) {
+                sendToWcsRequest.setDestination(newDestination);
+            }
+            ResponseEntity response1;
+            for (int i = 0; i < 5; i++) {
+                response1 = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_CHANGE_TASK.getValue(), JSON.toJSONString(sendToWcsRequest)), ResponseEntity.class);
+                logger.info("向WCS反馈任务状态变更");
+                if (Objects.equals(response1.getCode(), 0)) {// 发送成功，则不再发送；不成功，一共尝试发送5次
+                    break;
+                }
+            }
+            logger.info("更新任务状态成功");
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("更新任务状态成功");
+            return JSON.toJSONString(response);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("发生异常{}", e.getMessage());
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("发生异常" + e.getMessage());
+            return JSON.toJSONString(response);
+        }
+    }
+
+//    /**
+//     * 更改任务状态
+//     *
+//     * @param request 请求参数
+//     * @return 结果
+//     */
+//    @PostMapping("/changeTaskStatus")
+//    @ResponseBody
+//    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+//    public String changeTaskStatus(@RequestBody Task request) {
+//        logger.info("用户请求更改任务状态，用户名：{}，ip地址：{}", request.getUserName(), HttpUtils.getIpAddr(servletRequest));
+//        logger.info("请求详细：{}", JSON.toJSONString(request));
+//        ResponseEntity response = new ResponseEntity();
+//        try {
+//            if (request.getTaskStatus() == null) {
+//                logger.error("请选择任务状态");
+//                response.setCode(ResponseCode.ERROR.getCode());
+//                response.setMessage("请选择任务状态");
+//                return JSON.toJSONString(response);
+//            }
+//            // 更改后的任务状态
+//            int taskStatusRequest = request.getTaskStatus();
+//            int wcsTaskStatusAfter = 0;
+//            // 查询任务
+//            Task taskQuery = new Task();
+//            taskQuery.setTaskId(request.getTaskId());
+//            List<Task> tasks = taskService.selTasks(taskQuery);
+//            if (tasks.isEmpty()) {
+//                logger.error("当前任务不存在");
+//                response.setCode(ResponseCode.ERROR.getCode());
+//                response.setMessage("当前任务不存在");
+//                return JSON.toJSONString(response);
+//            }
+//            Task currentTask = tasks.get(0);
+//            String taskGroupId = currentTask.getTaskGroup();
+//            if (taskStatusRequest == 1) {// 取消任务
+//                logger.info("任务取消");
+//                WmsReceiveTaskResultEntity sendToWmsRequest = new WmsReceiveTaskResultEntity();
+//                sendToWmsRequest.setTaskId(taskGroupId);
+//                sendToWmsRequest.setTaskStatus(WcsTaskStatus.CANCEL.getCode());
+//                sendToWmsRequest.setVehicleNo(currentTask.getVehicleNo());
+//                sendToWmsRequest.setDestination(currentTask.getDestination());
+//                logger.info(taskController.receiveTaskResult(sendToWmsRequest));
+//                wcsTaskStatusAfter = 999;
+//            } else if (taskStatusRequest == 2) {// 完成任务
+//                logger.info("任务完成");
+//                WmsReceiveTaskResultEntity sendToWmsRequest = new WmsReceiveTaskResultEntity();
+//                sendToWmsRequest.setTaskId(taskGroupId);
+//                sendToWmsRequest.setTaskStatus(WcsTaskStatus.FINISH.getCode());
+//                sendToWmsRequest.setVehicleNo(currentTask.getVehicleNo());
+//                sendToWmsRequest.setDestination(currentTask.getDestination());
+//                taskController.receiveTaskResult(sendToWmsRequest);
+//                wcsTaskStatusAfter = 3;
+//            }
+//            // 向WCS反馈
+//            WmsReceiveTaskResultEntity sendToWcsRequest = new WmsReceiveTaskResultEntity();
+//            sendToWcsRequest.setTaskId(taskGroupId);
+//            sendToWcsRequest.setTaskStatus(wcsTaskStatusAfter);
+//            ResponseEntity response1;
+//            for (int i = 0; i < 5; i++) {
+//                response1 = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_CHANGE_TASK.getValue(), JSON.toJSONString(sendToWcsRequest)), ResponseEntity.class);
+//                logger.info("向WCS反馈任务状态变更");
+//                if (Objects.equals(response1.getCode(), 0)) {// 发送成功，则不再发送；不成功，一共尝试发送5次
+//                    break;
+//                }
+//            }
+//            logger.info("更新任务状态成功");
+//            response.setCode(ResponseCode.OK.getCode());
+//            response.setMessage("更新任务状态成功");
+//            return JSON.toJSONString(response);
+//        } catch (Exception e) {
+//            // 回滚事务
+//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+//            logger.error("发生异常{}", e.getMessage());
+//            response.setCode(ResponseCode.ERROR.getCode());
+//            response.setMessage("发生异常" + e.getMessage());
+//            return JSON.toJSONString(response);
+//        }
+//    }
+
+    /**
+     * 删除kate清单数据
+     *
+     * @param request 请求参数
+     * @return 结果
+     */
+    @PostMapping("/deleteAllKateTasks")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String deleteAllKateTasks(@RequestBody Task request) {
+        logger.info("用户请求删除配料任务清单，包括配件、合件、紧急件，用户名：{}，ip地址：{}", request.getUserName(), HttpUtils.getIpAddr(servletRequest));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            // 有任务正在执行时不允许删除清单
+            Task taskQuery = new Task();
+            taskQuery.setTaskType(TaskType.OUT.getCode());
+            List<Task> tasks = taskService.selTasks(taskQuery);
+            if (tasks.size() > 0) {
+                for (Task task : tasks) {
+                    if (StringUtils.isNotEmpty(task.getKateTaskId())) {// 卡特任务未做完
+                        logger.error("卡特任务未做完，不允许删除");
+                        response.setCode(ResponseCode.ERROR.getCode());
+                        response.setMessage("卡特任务未做完，不允许删除");
+                        return JSON.toJSONString(response);
+                    }
+                }
+            }
+            stockService.resetStock(new Stock());
+            logger.info("删除任务清单成功");
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("删除任务清单成功");
+            return JSON.toJSONString(response);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("发生异常{}", e.getMessage());
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("发生异常" + e.getMessage());
+            return JSON.toJSONString(response);
+        }
+    }
+}

src/main/java/com/wms/controller/TestController.java

@@ -0,0 +1,255 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.wms.constants.enums.LocationStatus;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.constants.enums.VehicleStatus;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.table.Location;
+import com.wms.entity.table.User;
+import com.wms.entity.table.Vehicle;
+import com.wms.entity.test.ExcelTest;
+import com.wms.mapper.VehicleMapper;
+import com.wms.service.LocationService;
+import com.wms.service.VehicleService;
+import com.wms.utils.MyPassword;
+import com.wms.utils.excel.ExcelUtils;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 测试控制类
+ */
+@Controller
+@CrossOrigin
+@RequestMapping(value = "/wms/test")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class TestController extends BaseController {
+    /**
+     * 库位服务
+     */
+    private final LocationService locationService;
+    private final VehicleService vehicleService;
+    private final VehicleMapper vehicleMapper;
+
+
+    @PostMapping("/test")
+    @ResponseBody
+    public String test() {
+       vehicleMapper.updateLocation("1", "A-03-04-A-02");
+       return "success";
+    }
+
+    @PostMapping("/genLocations")
+    @ResponseBody
+    public String genLocations() {
+        // 巷道1  一共2排45列12层
+        for (int i = 3; i < 4; i++) {// 排
+            for (int j = 4; j <= 22; j=j+2) {// 列
+                for (int k = 1; k <= 4; k++) {
+                    Location tempLocation = new Location();
+                    tempLocation.setLocationId("A-" + StringUtils.leftPad(String.valueOf(i), 2, "0") + "-" + StringUtils.leftPad(String.valueOf(j), 2, "0") + "-A-" + StringUtils.leftPad(String.valueOf(k), 2, "0"));
+                    tempLocation.setAreaId(1);
+                    tempLocation.setTunnelId(1);
+                    tempLocation.setEquipmentId(1);
+                    tempLocation.setLocationType(0);
+                    tempLocation.setQueue(6);
+                    if ((k == 1 || k == 3)){
+                        tempLocation.setLine(j-2);
+                    }else {
+                        tempLocation.setLine(j-1);
+                    }
+                    tempLocation.setLayer(1);
+                    if (k == 1 || k == 2){
+                        tempLocation.setDepth(2);
+                    }else {
+                        tempLocation.setDepth(1);
+                    }
+                    tempLocation.setIsLock(0);
+                    tempLocation.setLocationStatus(0);
+                    tempLocation.setWareArea("B");
+                    if (locationService.selLocations(tempLocation).isEmpty()) {
+                        locationService.addLocation(tempLocation);
+                    }
+                }
+            }
+        }
+//        // 巷道2
+//        for (int i = 3; i <= 4; i++) {// 排
+//            for (int j = 3; j <= 34; j++) {// 列
+//                Location tempLocation = new Location();
+//                tempLocation.setLocationId(StringUtils.leftPad(String.valueOf(i), 2, "0") + StringUtils.leftPad(String.valueOf(j), 2, "0") + StringUtils.leftPad(String.valueOf(13), 2, "0"));
+//                tempLocation.setAreaId(1);
+//                tempLocation.setTunnelId(2);
+//                tempLocation.setEquipmentId(2);
+//                tempLocation.setLocationType(0);
+//                tempLocation.setQueue(i);
+//                tempLocation.setLine(j);
+//                tempLocation.setLayer(13);
+//                tempLocation.setDepth(1);
+//                tempLocation.setIsLock(0);
+//                tempLocation.setLocationStatus(0);
+//                locationService.addLocation(tempLocation);
+//            }
+//        }
+        return "success";
+    }
+
+    @PostMapping("/genETagLocations")
+    @ResponseBody
+    public String genETagLocations() {
+//        for (int i = 1; i <= 40; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("A" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("1");
+//            eTagLocation.setStandId("2001");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+//        for (int i = 1; i <= 70; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("B" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("2");
+//            eTagLocation.setStandId("2002");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+//        for (int i = 1; i <= 70; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("C" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("3");
+//            eTagLocation.setStandId("2003");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+//        for (int i = 1; i <= 70; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("D" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("4");
+//            eTagLocation.setStandId("2004");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+//        for (int i = 1; i <= 70; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("E" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("5");
+//            eTagLocation.setStandId("2005");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+//        for (int i = 1; i <= 70; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("F" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("6");
+//            eTagLocation.setStandId("2006");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+//        for (int i = 1; i <= 70; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("G" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("7");
+//            eTagLocation.setStandId("2007");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+//        for (int i = 1; i <= 40; i++) {
+//            ETagLocation eTagLocation = new ETagLocation();
+//            eTagLocation.setLocationId("H" + StringUtils.leftPad(String.valueOf(i), 2, "0"));
+//            eTagLocation.setAreaId("8");
+//            eTagLocation.setStandId("2008");
+//            eTagLocation.setSequenceNo(i);
+//            eTagLocationService.addETagLocation(eTagLocation);
+//        }
+        return "success";
+    }
+
+    /**
+     * 测试导入
+     *
+     * @param file 文件
+     * @return 导入结果
+     */
+    @PostMapping("/testExcelImport")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String testExcelImport(@RequestPart("file") MultipartFile file) {
+        ResponseEntity response = new ResponseEntity();
+        try {
+            List<ExcelTest> tests = ExcelUtils.readMultipartFile(file, ExcelTest.class);
+            for (ExcelTest test : tests) {
+                // 更新库位
+                Location locationQuery = new Location();
+                locationQuery.setLocationId(test.getLocationId());
+                List<Location> locations = locationService.selLocations(locationQuery);
+                if (locations.size() > 0) {
+                    Location currentLocation = locations.get(0);
+                    currentLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+                    currentLocation.setVehicleId("XZBK" + StringUtils.leftPad(test.getVehicleId().trim(), 4, "0"));
+                    locationService.modifyLocation(currentLocation);
+                    // 添加载具
+                    Vehicle vehicle = new Vehicle();
+                    vehicle.setVehicleId("XZBK" + StringUtils.leftPad(test.getVehicleId().trim(), 4, "0"));
+                    vehicle.setCurrentLocation(test.getLocationId());
+                    vehicle.setVehicleStatus(VehicleStatus.ON.getCode());
+                    vehicle.setIsEmpty(1);
+                    if (vehicleService.selVehicleById(test.getVehicleId()) == null) {
+                        vehicleService.addVehicle(vehicle);
+                    } else {
+                        vehicleService.modifyVehicle(vehicle);
+                    }
+                }
+            }
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("导入excel成功");
+            response.setReturnData(tests);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("导入excel发生错误");
+        }
+        logger.info(JSON.toJSONString(response));
+        return JSON.toJSONString(response);
+    }
+
+    /**
+     * 测试导出
+     *
+     * @param response 请求
+     */
+    @GetMapping("/testExcelExport")
+    @ResponseBody
+    public void testExcelExport(HttpServletResponse response) {
+        List<ExcelTest> tests = new ArrayList<>();
+        ExcelTest temp1 = new ExcelTest("010101", "XZBK0001");
+        ExcelTest temp2 = new ExcelTest("020101", "XZBK0002");
+        tests.add(temp1);
+        tests.add(temp2);
+        ExcelUtils.export(response, "测试导出", tests, ExcelTest.class);
+    }
+
+    @PostMapping("/genPassword")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String genPassword(@RequestBody User user) {
+        ResponseEntity response = new ResponseEntity();
+        response.setCode(ResponseCode.OK.getCode());
+        response.setMessage("创建密码成功");
+        response.setReturnData(MyPassword.encrypt(user.getLoginPassword()));
+        return JSON.toJSONString(response);
+    }
+}

src/main/java/com/wms/controller/UserController.java

@@ -0,0 +1,794 @@
+package com.wms.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.wms.constants.enums.ResponseCode;
+import com.wms.entity.app.MenuEntity;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.UserConfigEntity;
+import com.wms.entity.app.vo.RoleOption;
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.dto.user.*;
+import com.wms.entity.table.*;
+import com.wms.service.MenuService;
+import com.wms.service.PermissionService;
+import com.wms.service.RoleService;
+import com.wms.service.UserService;
+import com.wms.utils.MyPassword;
+import com.wms.constants.WmsConstants;
+import com.wms.utils.StringUtils;
+import jakarta.servlet.http.HttpSession;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Controller;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.wms.utils.StringUtils.convertJsonString;
+
+/**
+ * WMS用户控制类
+ * @author 梁州
+ * @date  2023/2/14
+ */
+@Controller
+@CrossOrigin
+@RequestMapping(value = "/wms/user")
+@RequiredArgsConstructor
+public class UserController extends BaseController {
+    /**
+     * 用户服务
+     */
+    private final UserService userService;
+    /**
+     * 菜单服务
+     */
+    private final MenuService menuService;
+    private final PermissionService permissionService;
+    private final RoleService roleService;
+
+    //private final HttpServletRequest servletRequest;
+
+    /**
+     * 带密码登录
+     * @param user 用户
+     * @return 结果
+     */
+    @PostMapping("/loginWithAuth")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String loginWithAuth(@RequestBody User user, HttpSession session) {
+        logger.info("WMS前端用户登录，登录账户名：{}", user.getLoginAccount());
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            // 查找对应用户的信息
+            User userForQuery = new User();
+            userForQuery.setLoginAccount(user.getLoginAccount());
+            List<User> waitForAuthUsers = userService.selectUsers(userForQuery);
+            if (waitForAuthUsers.size() < 1) {
+                logger.error("用户不存在，登录账户名：{}", user.getLoginAccount());
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("用户不存在");
+                return JSON.toJSONString(rsp);
+            }
+            // 验证密码
+            User waitForAuthUser = waitForAuthUsers.get(0);
+            if (!Objects.equals(MyPassword.encrypt(user.getLoginPassword()), waitForAuthUser.getLoginPassword())) {
+                logger.error("密码错误，登录账户名：{}", user.getLoginAccount());
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("密码错误");
+                return JSON.toJSONString(rsp);
+            }
+            // 当前用户
+            User currentUser = waitForAuthUsers.get(0);
+
+            // 将用户名保存到会话中
+            session.setAttribute("username", currentUser.getLoginAccount());
+
+            // 返回成功
+            logger.info("登录成功，登录账户名：{}", currentUser.getLoginAccount());
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("登录成功");
+            // 返回用户数据
+            UserConfigEntity userConfigEntity = generateUserInfo(currentUser);
+            rsp.setReturnData(userConfigEntity);
+
+            return JSON.toJSONString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("数据库错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage(e.getMessage());
+            return JSON.toJSONString(rsp);
+        }
+    }
+
+
+    /**
+     * 无密码登录
+     * @param user 用户
+     * @return 结果
+     */
+    @PostMapping("/loginWithoutAuth")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String loginWithoutAuth(@RequestBody User user) {
+        logger.info("WMS前端用户登录，登录账户名：{}", user.getLoginAccount());
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            // 查找对应用户的信息
+            User userForQuery = new User();
+            userForQuery.setLoginAccount(user.getLoginAccount());
+            List<User> waitForAuthUsers = userService.selectUsers(userForQuery);
+            if (waitForAuthUsers.size() < 1) {
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("用户不存在");
+                return JSON.toJSONString(rsp);
+            }
+            User currentUser = waitForAuthUsers.get(0);
+            // 返回成功
+            logger.info("登录成功，登录账户名：{}", currentUser.getLoginAccount());
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("登录成功");
+            // 返回用户数据
+            rsp.setReturnData(generateUserInfo(currentUser));
+            return JSON.toJSONString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("数据库错误：{}", e.getMessage());
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("数据库错误");
+            return JSON.toJSONString(rsp);
+        }
+    }
+
+
+    /**
+    * 查询所有用户
+    * @return 用户信息
+    * */
+    @PostMapping("/getUserList")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String getUserList(@RequestBody queryUserRequest request) {
+        ResponseEntity rsp = new ResponseEntity();
+        User user = new User();
+        user.setUserName(request.getUserName());
+        List<User> queryUserLists = userService.selectUsers(user);
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("查询成功");
+        rsp.setReturnData(queryUserLists);
+        return JSON.toJSONString(rsp);
+    }
+
+
+
+
+    /**
+     * 新增用户
+     * @return 用户信息
+     * */
+    @PostMapping("/addUserInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String addUser(@RequestBody addUser request) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        if (request.getRoleId1() != 1) {
+            logger.error("操作人员必须是管理员级别。");
+            // 返回错误
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("操作人员必须是管理员级别。");
+            return convertJsonString(rsp);
+        }
+        //先查看是否有重复的账号名
+        User userForQuery = new User();
+        userForQuery.setLoginAccount(request.getLoginAccountUpdate());
+        if (!userService.selectUsers(userForQuery).isEmpty()){
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("账号名重复");
+            return convertJsonString(rsp);
+        }
+        List<User> queryUserLists = userService.selectUsers(new User());//125
+        int userId = 1;
+        for (User user : queryUserLists){
+            if (userId == user.getUserId()){
+                userId = user.getUserId() + 1;
+            }else if (userId < user.getUserId()){
+                break;
+            }
+        }
+        User user = new User();
+        user.setUserId(userId);
+        user.setUserName(request.getUserNameUpdate());
+        user.setRoleId(request.getRoleIdUpdate());
+        user.setLoginAccount(request.getLoginAccountUpdate());
+        user.setLoginPassword(MyPassword.encrypt(request.getLoginPasswordUpdate()));
+        user.setAddTime(new Date());
+        user.setUpdateTime(new Date());
+        user.setAddUser("系统");
+        int a = userService.addUsers(user);
+        if (a > 0){
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("添加成功");
+            return convertJsonString(rsp);
+        }
+        rsp.setCode(ResponseCode.ERROR.getCode());
+        rsp.setMessage("添加失败");
+        return convertJsonString(rsp);
+    }
+
+
+    /**
+     * 删除用户信息
+     * @return 用户信息
+     * */
+    @PostMapping("/deleteUserInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String deleteCurrentRow(@RequestBody updateUser request) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        if (request.getRoleId1() != 1) {
+            logger.error("操作人员必须是管理员级别。");
+            // 返回错误
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("操作人员必须是管理员级别。");
+            return convertJsonString(rsp);
+        }
+        if(userService.deleteUser(request.getUserIdUpdate()) > 0){
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("删除成功");
+            return convertJsonString(rsp);
+        }
+        rsp.setCode(ResponseCode.ERROR.getCode());
+        rsp.setMessage("删除失败");
+        return convertJsonString(rsp);
+    }
+
+    /**
+     * 修改用户信息
+     * @return 用户信息
+     * */
+    @PostMapping("/updateUserInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateUserInfo(@RequestBody updateUser request) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        if (request.getRoleId1() != 1) {
+            logger.error("操作人员必须是管理员级别。");
+            // 返回错误
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("操作人员必须是管理员级别。");
+            return convertJsonString(rsp);
+        }
+        //先查看是否有重复的账号名
+        User userForQuery = new User();
+        userForQuery.setLoginAccount(request.getLoginAccountUpdate());
+//        if (!userService.selectUsers(userForQuery).isEmpty()){
+//            rsp.setCode(ResponseCode.ERROR.getCode());
+//            rsp.setMessage("新的账号名已存在");
+//            return convertJsonString(rsp);
+//        }
+        //更新账户信息
+        userForQuery.setUserName(request.getUserNameUpdate());
+        userForQuery.setUserId(request.getUserIdUpdate());
+        userForQuery.setRoleId(request.getRoleIdUpdate());
+        int a = userService.updateUserInfromation(userForQuery);
+        if (a > 0){
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("添加成功");
+            return convertJsonString(rsp);
+        }
+        rsp.setCode(ResponseCode.ERROR.getCode());
+        rsp.setMessage("添加失败");
+        return convertJsonString(rsp);
+    }
+
+    /**
+     * 删除用户
+     * @return 用户信息
+     * */
+    @DeleteMapping("/deleteUser/{userId}")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public WmsApiResponse<Object> deleteUser(@PathVariable int userId) {
+       int a = userService.deleteUser(userId);
+       if (a > 0){
+           return new WmsApiResponse<>(0, "删除成功", true);
+       }
+       return new WmsApiResponse<>(-1, "删除失败", false);
+    }
+
+    /**
+     * 修改用户密码
+     * @param request 修改用户密码的请求
+     * @return 用户信息
+     */
+    @PostMapping("/changePassword")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public WmsApiResponse<Object> changePassword(@RequestBody deleteUser request) {
+        if (Objects.equals(request.getZhanghao(), "admin")){
+            return new WmsApiResponse<>(-1, "管理员密码不允许修改", false);
+        }
+        User user = new User();
+        user.setLoginAccount(request.getZhanghao());
+        List<User> userList = userService.selectUsers(user);
+        if (userList.isEmpty()){
+            return new WmsApiResponse<>(-1, "用户不存在，请核对！", false);
+        }
+        if (Objects.equals(MyPassword.encrypt(request.getOldPW()), userList.get(0).getLoginPassword())){
+            user.setLoginPassword(MyPassword.encrypt(request.getNewPW()));
+            int a = userService.updateUser(user);
+            if (a > 0){
+                return new WmsApiResponse<>(0, "修改成功", true);
+            }else {
+                return new WmsApiResponse<>(-1, "修改失败", false);
+            }
+        }else {
+            return new WmsApiResponse<>(-1, "旧密码错误，请核对！", false);
+        }
+    }
+
+
+    /**
+     * 构造用户信息（菜单、按钮等权限）
+     * @param currentUser 当前用户
+     * @return 用户信息
+     */
+    private UserConfigEntity generateUserInfo (User currentUser) {
+        UserConfigEntity userConfigEntity = new UserConfigEntity();
+        try {
+            List<Menu> menus = menuService.selMenuByRoleId(currentUser.getRoleId());
+            List<MenuEntity> menuList = new LinkedList<>();
+            // 查找一级菜单
+            for (Menu firstMenu : menus) {
+                if (WmsConstants.ROOT_MENU_ID.equals(firstMenu.getParentId())) {// 查找到所有的一级子菜单
+                    MenuEntity tempFirstMenu = new MenuEntity();
+                    tempFirstMenu.setId(firstMenu.getMenuId());// ID
+                    tempFirstMenu.setLabelName(firstMenu.getLabelName());// 菜单显示名称
+                    tempFirstMenu.setIconValue(firstMenu.getIconValue());// 图标
+                    tempFirstMenu.setPath(firstMenu.getPath());// 路径
+                    // 设置子菜单
+                    List<MenuEntity> tempFirstMenuChildren = new LinkedList<>();
+                    for (Menu secondMenu : menus) {
+                        if (firstMenu.getMenuId().equals(secondMenu.getParentId())) {
+                            MenuEntity tempSecondMenu = new MenuEntity();
+                            tempSecondMenu.setId(secondMenu.getMenuId());// ID
+                            tempSecondMenu.setLabelName(secondMenu.getLabelName());// 菜单显示名称
+                            tempSecondMenu.setIconValue(secondMenu.getIconValue());// 图标
+                            tempSecondMenu.setPath(secondMenu.getPath());// 路径
+                            // 设置子菜单
+                            List<MenuEntity> tempSecondMenuChildren = new LinkedList<>();
+                            for (Menu thirdMenu : menus) {
+                                if (secondMenu.getMenuId().equals(thirdMenu.getParentId())) {
+                                    MenuEntity tempThirdMenu = new MenuEntity();
+                                    tempSecondMenu.setId(thirdMenu.getMenuId());// ID
+                                    tempSecondMenu.setLabelName(thirdMenu.getLabelName());// 菜单显示名称
+                                    tempSecondMenu.setIconValue(thirdMenu.getIconValue());// 图标
+                                    tempSecondMenu.setPath(thirdMenu.getPath());// 路径
+                                    // 添加按钮
+                                    tempSecondMenuChildren.add(tempThirdMenu);
+                                }
+                            }
+                            tempSecondMenu.setChildren(tempSecondMenuChildren);
+                            // 添加二级菜单
+                            tempFirstMenuChildren.add(tempSecondMenu);
+                        }
+                    }
+                    tempFirstMenu.setChildren(tempFirstMenuChildren);
+                    // 添加一级菜单
+                    menuList.add(tempFirstMenu);
+                }
+            }
+            logger.info("构造用户信息成功，当前用户：{}", currentUser.toLoggerString());
+            // 设置返回信息
+            userConfigEntity.setUser(currentUser);
+            userConfigEntity.setMenuList(menuList);
+        } catch (Exception e) {
+            logger.error("构造用户信息失败，当前用户：{}", currentUser.toLoggerString());
+        }
+        return  userConfigEntity;
+    }
+
+
+    /**
+     * 查询所有的role返回
+     * @return 用户信息
+     * */
+    @PostMapping("/getRoleOptions")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String selectUserRole() {
+        List<Role> roles = roleService.selectRoles(new Role());
+        List<RoleOption> roleOptions = roles.stream().map(RoleOption::of).toList();
+        ResponseEntity rsp = new ResponseEntity();
+        rsp.setCode(ResponseCode.OK.getCode());
+        rsp.setMessage("查询成功");
+        rsp.setReturnData(roleOptions);
+        return JSON.toJSONString(rsp);
+    }
+
+
+    // TODO 以下代码是新增
+    /**
+     * 获取角色列表
+     *
+     * @param roleQuery 查询参数
+     * @return 结果
+     */
+    @PostMapping("/getRoleList")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String getRoleList(@RequestBody Role roleQuery) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (roleQuery.getRoleId() == null || roleQuery.getRoleId() != 1) {
+                logger.error("操作人员必须是管理员级别。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员必须是管理员级别。");
+                return convertJsonString(rsp);
+            }
+            // 查询roleId低于当前查询的roleId的用户
+            List<Role> roles = roleService.selectRoles(roleQuery);
+            // 返回成功
+            logger.info("查询角色列表成功。");
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("查询角色列表成功。");
+            // 返回用户数据
+            rsp.setReturnData(roles);
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("查询角色列表失败：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("查询角色列表失败。");
+            return convertJsonString(rsp);
+        }
+    }
+
+    /**
+     * 获取权限列表
+     *
+     * @param permissionQuery 查询参数
+     * @return 结果
+     */
+    @PostMapping("/getPermissionList")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String getPermissionList(@RequestBody PermissionQuery permissionQuery) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (permissionQuery.getRoleId1() == null || permissionQuery.getRoleId1() != 1) {
+                logger.error("操作人员必须是管理员级别。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员必须是管理员级别。");
+                return convertJsonString(rsp);
+            }
+            // 获取所有的菜单信息
+            List<Permission> permissionList = permissionService.selectPermissionByRoleId(permissionQuery.getRoleId1());
+            if (permissionList == null || permissionList.isEmpty()) {
+                logger.error("操作人员的角色没有权限。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员的角色没有权限。");
+                return convertJsonString(rsp);
+            }
+            List<String> menuIds = permissionList.stream().map(Permission::getMenuId).distinct().toList();
+            // 查询所有的菜单
+            List<Menu> menuList = menuService.selMenuByMenuIds(menuIds);
+            // 先添加一级菜单
+            List<MenuVo> level1Menus = menuList.stream().filter(menu -> Objects.equals(menu.getParentId(), WmsConstants.ROOT_MENU_ID)).map(MenuVo::of).toList();
+            // 添加二级菜单
+            for (MenuVo level1Menu : level1Menus) {
+                level1Menu.setChildren(menuList.stream().filter(menu -> Objects.equals(menu.getParentId(), level1Menu.getId())).map(MenuVo::of).toList());
+            }
+            PermissionVo permissionVo = new PermissionVo();
+            permissionVo.setMenu(level1Menus);
+            // 获取待查询角色所有菜单权限
+            if (permissionQuery.getRoleId2() != null) {
+                List<Permission> permissionListOfTarget = permissionService.selectPermissionWithOutL1(permissionQuery.getRoleId2(), level1Menus.stream().map(MenuVo::getId).distinct().toList());
+                permissionVo.setMenuIds(permissionListOfTarget.stream().map(Permission::getMenuId).distinct().toList());
+            } else {
+                permissionVo.setMenuIds(new ArrayList<>());
+            }
+
+            logger.info("查询权限列表成功。");
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("查询权限列表成功。");
+            // 返回用户数据
+            rsp.setReturnData(permissionVo);
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            // 返回其他异常
+            logger.error("查询权限列表异常：{}", convertJsonString(e));
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("查询权限列表异常。");
+            return convertJsonString(rsp);
+        }
+    }
+
+    /**
+     * 更新角色信息
+     *
+     * @param roleUpdateForm 更新参数
+     * @return 结果
+     */
+    @PostMapping("/updateRoleInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String updateRoleInfo(@RequestBody RoleUpdateForm roleUpdateForm) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (roleUpdateForm.getRoleId1() == null || roleUpdateForm.getRoleId2() == null) {
+                logger.error("请求操作的roleId和被操作的roleId必须输入。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("请求操作的roleId和被操作的roleId必须输入。");
+                return convertJsonString(rsp);
+            }
+            if (roleUpdateForm.getRoleId1() != 1) {
+                logger.error("操作人员必须是管理员级别。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员必须是管理员级别。");
+                return convertJsonString(rsp);
+            }
+            // 更新角色信息
+            if (StringUtils.isNotEmpty(roleUpdateForm.getRole2Name())) {
+                roleService.updateRole(new Role(roleUpdateForm.getRoleId2(), roleUpdateForm.getRole2Name()));
+            }
+            // 获取所有的菜单信息
+            List<Permission> permissionList = permissionService.selectPermissionByRoleId(roleUpdateForm.getRoleId1());
+            if (permissionList == null || permissionList.isEmpty()) {
+                logger.error("操作人员的角色没有权限。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员的角色没有权限。");
+                return convertJsonString(rsp);
+            }
+            List<String> menuIds = permissionList.stream().map(Permission::getMenuId).distinct().toList();
+            List<String> updateMenuIds = roleUpdateForm.getMenuIds();
+            for (String menuId : updateMenuIds) {
+                if (!menuIds.contains(menuId)) {
+                    logger.error("设定的权限超过操作人员所拥有的权限。");
+                    // 返回错误
+                    rsp.setCode(ResponseCode.ERROR.getCode());
+                    rsp.setMessage("设定的权限超过操作人员所拥有的权限。");
+                    return convertJsonString(rsp);
+                }
+            }
+            // 查询所有的菜单
+            List<Menu> menuList = menuService.selMenuByMenuIds(updateMenuIds);
+            for (Menu menu : menuList) {
+                if (menu.getParentId() != null && !menu.getParentId().equals(WmsConstants.ROOT_MENU_ID) && !updateMenuIds.contains(menu.getParentId())) {
+                    updateMenuIds.add(menu.getParentId());
+                }
+            }
+            // 移除角色所有权限
+            permissionService.removePermissonsByRoleId(roleUpdateForm.getRoleId2());
+            // 添加权限
+            List<Permission> updatePermissionList = new ArrayList<>();
+            List<Permission> list =  permissionService.selectAll();
+            int a = 0;
+            for (Permission permission : list) {
+                if (a <= Integer.parseInt(permission.getPermissionId())) {
+                    a = Integer.parseInt(permission.getPermissionId()) + 1;
+                }
+            }
+            for (int i = 0; i < updateMenuIds.size(); i++) {
+//                if(Objects.equals(updateMenuIds.get(i), "1") || Objects.equals(updateMenuIds.get(i), "2") || Objects.equals(updateMenuIds.get(i), "3")){
+//                    continue;
+//                }
+                Permission permission = new Permission();
+                permission.setRoleId(roleUpdateForm.getRoleId2());
+                permission.setMenuId(updateMenuIds.get(i));
+                permission.setPermissionId(String.valueOf(a + i));
+                updatePermissionList.add(permission);
+            }
+            if (permissionService.saveBatch(updatePermissionList) > 0) {
+                // 返回成功
+                logger.info("更新角色信息成功。");
+                rsp.setCode(ResponseCode.OK.getCode());
+                rsp.setMessage("更新角色信息成功。");
+            } else {
+                // 返回失败
+                logger.error("更新角色权限失败。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("更新角色权限失败。");
+            }
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("更新角色信息失败：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("更新角色信息失败。");
+            return convertJsonString(rsp);
+        }
+    }
+
+    /**
+     * 添加角色信息
+     *
+     * @param roleUpdateForm 添加参数
+     * @return 结果
+     */
+    @PostMapping("/addRoleInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String addRoleInfo(@RequestBody RoleUpdateForm roleUpdateForm) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (roleUpdateForm.getRoleId1() == null || roleUpdateForm.getRoleId1() != 1) {
+                logger.error("操作人员必须是管理员级别。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员必须是管理员级别。");
+                return convertJsonString(rsp);
+            }
+            // 添加角色信息
+            Role role = new Role();
+            role.setRoleId(roleService.selectMaxRoleId().getRoleId() + 1);
+            role.setRoleName(roleUpdateForm.getRole2Name());
+            if (roleService.addRole(role) == 0) {
+                // 添加失败
+                logger.error("添加角色信息失败。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("添加角色信息失败。");
+                return convertJsonString(rsp);
+            }
+            // 获取所有的菜单信息
+            List<Permission> permissionList = permissionService.selectPermissionByRoleId(roleUpdateForm.getRoleId1());
+            if (permissionList == null || permissionList.isEmpty()) {
+                logger.error("操作人员的角色没有权限。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员的角色没有权限。");
+                return convertJsonString(rsp);
+            }
+            List<String> menuIds = permissionList.stream().map(Permission::getMenuId).distinct().toList();
+            List<String> updateMenuIds = roleUpdateForm.getMenuIds();
+            for (String menuId : updateMenuIds) {
+                if (!menuIds.contains(menuId)) {
+                    logger.error("设定的权限超过操作人员所拥有的权限。");
+                    // 返回错误
+                    rsp.setCode(ResponseCode.ERROR.getCode());
+                    rsp.setMessage("设定的权限超过操作人员所拥有的权限。");
+                    return convertJsonString(rsp);
+                }
+            }
+            // 查询所有的菜单
+            List<Menu> menuList = menuService.selMenuByMenuIds(updateMenuIds);
+            for (Menu menu : menuList) {
+                if (menu.getParentId() != null && !menu.getParentId().equals(WmsConstants.ROOT_MENU_ID) && !updateMenuIds.contains(menu.getParentId())) {
+                    updateMenuIds.add(menu.getParentId());
+                }
+            }
+            // 移除角色所有权限
+            permissionService.removePermissonsByRoleId(role.getRoleId());
+            // 添加权限
+            List<Permission> updatePermissionList = new ArrayList<>();
+            List<Permission> list =  permissionService.selectAll();
+            int a = 0;
+            for (Permission permission : list) {
+                if (a <= Integer.parseInt(permission.getPermissionId())) {
+                    a = Integer.parseInt(permission.getPermissionId()) + 1;
+                }
+            }
+            for (int i = 0; i < updateMenuIds.size(); i++) {
+//                if(Objects.equals(updateMenuIds.get(i), "1") || Objects.equals(updateMenuIds.get(i), "2") || Objects.equals(updateMenuIds.get(i), "3")){
+//                    continue;
+//                }
+                Permission permission = new Permission();
+                permission.setRoleId(role.getRoleId());
+                permission.setMenuId(updateMenuIds.get(i));
+                permission.setPermissionId(String.valueOf(a + i));
+                updatePermissionList.add(permission);
+            }
+//            for (String menuId : updateMenuIds) {
+//                // 添加权限
+//                Permission permission = new Permission();
+//                permission.setRoleId(role.getRoleId());
+//                permission.setMenuId(menuId);
+//                updatePermissionList.add(permission);
+//            }
+            if (permissionService.saveBatch(updatePermissionList) > 0) {
+                // 返回成功
+                logger.info("添加角色信息成功。");
+                rsp.setCode(ResponseCode.OK.getCode());
+                rsp.setMessage("添加角色信息成功。");
+            } else {
+                // 返回失败
+                logger.error("添加角色权限失败。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("添加角色权限失败。");
+            }
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("添加角色信息失败：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("添加角色信息失败。");
+            return convertJsonString(rsp);
+        }
+    }
+
+    /**
+     * 删除角色信息
+     *
+     * @param roleUpdateForm 更新参数
+     * @return 结果
+     */
+    @PostMapping("/deleteRoleInfo")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String deleteRoleInfo(@RequestBody RoleUpdateForm roleUpdateForm) {
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (roleUpdateForm.getRoleId1() == null || roleUpdateForm.getRoleId2() == null) {
+                logger.error("请求操作的roleId和被操作的roleId必须输入。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("请求操作的roleId和被操作的roleId必须输入。");
+                return convertJsonString(rsp);
+            }
+            if (roleUpdateForm.getRoleId1() != 1) {
+                logger.error("操作人员必须是管理员级别。");
+                // 返回错误
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("操作人员必须是管理员级别。");
+                return convertJsonString(rsp);
+            }
+            // 删除角色信息
+            Role removeRole = new Role();
+            removeRole.setRoleId(roleUpdateForm.getRoleId2());
+            roleService.removeRole(removeRole);
+            // 移除角色所有权限
+            permissionService.removePermissonsByRoleId(roleUpdateForm.getRoleId2());
+            // 返回成功
+            logger.info("删除角色信息成功。");
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("删除角色信息成功。");
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("删除角色信息失败：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("删除角色信息失败。");
+            return convertJsonString(rsp);
+        }
+    }
+}

src/main/java/com/wms/controller/others/ContainerController.java

@@ -0,0 +1,71 @@
+package com.wms.controller.others;
+
+import com.alibaba.fastjson2.JSON;
+import com.wms.controller.BaseController;
+import com.wms.entity.app.container.ContainerApiLocalResponse;
+import com.wms.entity.app.container.CreateInstoreTaskRequest;
+import com.wms.entity.app.container.CreateInstoreTaskResponse;
+import com.wms.entity.app.container.TaskStateNoticeRequest;
+import com.wms.service.ContainerService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+
+/**
+ * 四向车交互
+ * @author icewint
+ */
+@Slf4j
+@RestController
+@CrossOrigin
+@RequestMapping(value = "/api/container")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class ContainerController extends BaseController {
+
+
+    private final ContainerService containerService;
+
+    /**
+     * 接收四向车扫码入库信息
+     * @param request 请求信息
+     * @return 返回信息
+     */
+    @PostMapping("/createInstoreTask")
+    public CreateInstoreTaskResponse createInstoreTask(@RequestBody @Validated CreateInstoreTaskRequest request) {
+        try {
+            log.info("四向车扫码入库请求：{}", JSON.toJSONString(request));
+            CreateInstoreTaskResponse instoreTask = containerService.createInstoreTask(request);
+            log.info("四向车扫码入库信息返回：{}", JSON.toJSONString(instoreTask));
+            return instoreTask;
+        }catch (Exception e){
+            log.info("四向车扫码入库失败，出现异常，请稍后再试");
+            return new CreateInstoreTaskResponse("400", "四向车扫码入库异常,请稍后再试");
+        }
+
+    }
+
+
+    /**
+     * 接收四向车任务状态通知
+     * @param request 请求信息
+     * @return 响应信息
+     */
+    @PostMapping("/taskStateNotice")
+    public ContainerApiLocalResponse taskStateNotice(@RequestBody @Validated TaskStateNoticeRequest request){
+        try {
+            log.info("四向车任务状态通知请求：{}", JSON.toJSONString(request));
+            ContainerApiLocalResponse containerApiLocalResponse = containerService.taskStateNotice(request);
+            log.info("四向车任务状态通知信息返回：{}", JSON.toJSONString(containerApiLocalResponse));
+            return containerApiLocalResponse;
+        }catch (Exception e){
+            log.error("接收到任务反馈失败，出现异常");
+            return new ContainerApiLocalResponse("400", "接收到任务反馈失败，请稍后再试");
+        }
+
+    }
+
+
+}

src/main/java/com/wms/controller/others/MesController.java

@@ -0,0 +1,57 @@
+package com.wms.controller.others;
+
+import com.wms.controller.BaseController;
+import com.wms.entity.app.mes.CheckNoticeRequest;
+import com.wms.entity.app.mes.MesApiLocalResponse;
+import com.wms.entity.app.mes.OutNoticeRequest;
+import com.wms.entity.app.mes.ReceiptInRequest;
+import com.wms.service.MesService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * 和 mes 交互使用的 controller
+ * @author icewint
+ */
+@RestController
+@CrossOrigin
+@RequestMapping(value = "/api/mes")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class MesController extends BaseController {
+
+    private final MesService mesService;
+
+    /**
+     * mes 入库之前用此接口推送信息 IF201
+     * @param request 请求信息
+     * @return 返回信息
+     */
+    @PostMapping("/ReceiptIn")
+    public MesApiLocalResponse receiptIn(@RequestBody @Validated ReceiptInRequest request) {
+        return mesService.receiptIn(request);
+    }
+
+
+    /**
+     * mes 出库 IF205(IF203)
+     * @param request 请求信息
+     * @return 返回信息
+     */
+    @PostMapping("/OutNotice")
+    public MesApiLocalResponse outNotice(@RequestBody @Validated OutNoticeRequest request) {
+       return mesService.outNotice(request);
+    }
+
+    /**
+     * mes 盘点通知单 IF206
+     * @return 返回信息
+     */
+    @PostMapping("/CheckNotice")
+    public MesApiLocalResponse checkNotice(@RequestBody @Validated CheckNoticeRequest request) {
+        return mesService.checkNotice(request);
+    }
+
+
+}

src/main/java/com/wms/controller/others/WcsController.java

@@ -0,0 +1,831 @@
+package com.wms.controller.others;
+
+import com.alibaba.fastjson2.JSON;
+import com.wms.bussiness.TaskOperation;
+import com.wms.constants.enums.*;
+import com.wms.entity.app.ResponseEntity;
+import com.wms.entity.app.container.ContainerApiLocalResponse;
+import com.wms.entity.app.mes.MesApiLocalResponse;
+import com.wms.entity.app.mes.SendMesPutInGoodsRequest;
+import com.wms.entity.app.wcs.RequireInRequest;
+import com.wms.entity.app.wcs.RequireOutRequest;
+import com.wms.entity.app.wcs.WmsReceiveTaskResultEntity;
+import com.wms.entity.common.WmsApiResponse;
+import com.wms.entity.table.*;
+import com.wms.mapper.*;
+import com.wms.service.StockService;
+import com.wms.service.TaskService;
+import com.wms.utils.HttpUtils;
+import com.wms.utils.storage.LocationUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.math.BigDecimal;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+@RestController
+@CrossOrigin
+@RequestMapping(value = "/api/wcs")
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class WcsController {
+
+    /**
+     * 任务操作类
+     */
+    private final TaskOperation taskOperation;
+
+    /**
+     * 库存 Mapper
+     */
+    private final StockMapper stockMapper;
+
+    /**
+     * 库位 Mapper
+     */
+    private final LocationMapper locationMapper;
+
+    /**
+     * 任务 Mapper
+     */
+    private final TaskMapper taskMapper;
+
+
+    /**
+     * 库存服务
+     */
+    private final StockService stockService;
+    /**
+     * 库位操作类
+     */
+    private final LocationUtils locationUtils;
+
+    /**
+     * 请求头部信息
+     */
+    private final HttpServletRequest servletRequest;
+
+    /**
+     * 任务服务
+     */
+    private final TaskService taskService;
+
+    /**
+     * 订单入库 Mapper
+     */
+    private final AppOrderInMapper appOrderInMapper;
+    private  final VehicleIistMapper vehicleIistMapper;
+    private final VehicleMapper vehicleMapper;
+    private final ConfigMapper configMapper;
+    private final PartInfoMapper partInfoMapper;
+    private final OledInMapper oledInMapper;
+    /**
+     * 插入oled入库信息
+     */
+    public boolean insertOledIn(oledIn oledIn){
+        return oledInMapper.insert(oledIn) > 0;
+    }
+
+
+    /**
+     * 电视机获取订单入库信息
+     * @return 返回信息
+     */
+    @GetMapping("/oledForOrderIn")
+    public ResponseEntity oledForOrderIn() {
+        //log.info("wcs请求获取oled入库信息");
+        ResponseEntity rsp = new ResponseEntity();
+        List<oledIn> oledInList = oledInMapper.selectAll();
+        if (oledInList == null || oledInList.isEmpty()) {
+            rsp.setCode(0);
+            rsp.setMessage("fail");
+            rsp.setReturnData(null);
+        } else {
+            rsp.setCode(200);
+            rsp.setMessage("success");
+            rsp.setReturnData(oledInList);
+        }
+        return rsp;
+    }
+
+    /**
+     * 更改一号入库口出入模式
+     * @param request 请求信息
+     * @return 返回信息
+     */
+    @PostMapping("/status")
+    public ResponseEntity status(@RequestBody @Validated RequireOutRequest request) {
+        log.info("wcs请求更改一号出入口状态");
+        //0为异常，既不能入也不能出，2为入库口，1为出库口
+        Config config = new Config();
+        config.setConfigId(100);
+        config.setConfigValue(request.getPoint());
+        int a = configMapper.updateConfig(config);
+        if (a > 0){
+            log.info("更新一号出入口状态成功");
+            return new ResponseEntity(0, "更新状态成功");
+        }else {
+            log.info("更新一号出入口状态失败");
+            return new ResponseEntity(-1, "更新状态失败");
+        }
+    }
+    /**
+     * 立库申请出空托垛
+     * @param request 请求信息
+     * @return 返回信息
+     */
+    @PostMapping("/requestOut")
+    public ResponseEntity requestOut(@RequestBody @Validated RequireOutRequest request) {
+        log.info("wcs呼叫空托垛出库");
+        //去载具表找一个空托，下发任务，终点写point
+        Vehicle vehicle = new Vehicle();
+        if(Objects.equals(request.getPoint(), "107")){
+            vehicle.setIsEmpty(1);
+        }else {
+            vehicle.setIsEmpty(0);
+        }
+        vehicle.setVehicleId("D99999999");
+        List<Vehicle> vList = vehicleMapper.selVehiclesByEmptyOut(vehicle);
+        if (vList == null || vList.isEmpty()){
+            return new ResponseEntity(-1, "库中没有空托垛，出库失败");
+        }
+        //下发出库任务
+        Task taskByEmptyOut = new Task();
+        taskByEmptyOut.setTaskId(UUID.randomUUID().toString());
+        taskByEmptyOut.setTaskType(TaskType.OUT.getCode());
+        taskByEmptyOut.setTaskStatus(WmsTaskStatus.NEW.getCode());
+        taskByEmptyOut.setTaskGroup(UUID.randomUUID().toString());
+        taskByEmptyOut.setOrigin(vList.get(0).getCurrentLocation());
+        taskByEmptyOut.setDestination(request.getPoint());
+        taskByEmptyOut.setPickStand(null);//因为出库要选择不同的站台，要区分大小托盘，用这个字段来标记
+        taskByEmptyOut.setWeight(0.0);
+        taskByEmptyOut.setVehicleNo(vList.get(0).getVehicleId());
+        taskByEmptyOut.setCreateTime(new Date());
+        taskByEmptyOut.setUserName(null);
+        taskByEmptyOut.setGoodsId(null);
+        taskByEmptyOut.setGoodsName(null);
+        taskByEmptyOut.setOperateNum(0);
+        taskByEmptyOut.setTotalNum(0);
+        taskByEmptyOut.setTaskPriority(1);
+        taskByEmptyOut.setRemark1("空托垛出库");
+        int addTask = taskMapper.addTask(taskByEmptyOut);
+        if(addTask > 0) {
+            return new ResponseEntity(0, "请求成功");
+        }else {
+            return new ResponseEntity(-1, "添加任务失败，网络连接异常，请稍后再试");
+        }
+    }
+
+    public RequireInRequest dealCodeInformation(RequireInRequest request) {
+        log.info("wcs请求处理二维码信息{}", request);
+        //新建一个oled表的信息
+        oledIn oledIn = new oledIn();
+        oledIn.setPoint(request.getPoint());
+        oledIn.setVehicleNo(request.getVehicleNo());
+        //先删除此点位所有非正常的记录
+        oledInMapper.delete(oledIn);
+        //检查母托信息
+        VechileList vehicle = new VechileList();
+        vehicle.setVehicleId(request.getVehicleNo());
+        if (vehicleIistMapper.selectByEqual(vehicle) == null || vehicleIistMapper.selectByEqual(vehicle).isEmpty()){
+            log.error("该母托号在数据库中不存在");
+            oledIn.setRemark("该母托号在数据库中不存在");
+            oledIn.setStatus("1");
+            insertOledIn(oledIn);
+            return null;
+        }
+        //查找该母托是否已有任务，有也要返回
+        Task taskQuery = new Task();
+        taskQuery.setVehicleNo(request.getVehicleNo());
+        if (taskService.selTasks(taskQuery) != null && !taskService.selTasks(taskQuery).isEmpty()){
+            log.error("该母托号已有任务");
+            oledIn.setRemark("该母托号已有任务");
+            oledIn.setStatus("1");
+            insertOledIn(oledIn);
+            return null;
+        }
+        //对wcs传过来的条码信息进行解析
+        PartInfo partInfo = new PartInfo();
+        //原材料的情况
+        if (request.getModel() == null || request.getModel().isEmpty()){//原材料
+            //检查原材料
+
+            String str = request.getCodeMessage();
+            if (str == null || !str.contains("&")) {
+                log.error("原材料条码格式错误");
+                oledIn.setRemark("原材料条码格式错误");
+                oledIn.setStatus("1");
+                insertOledIn(oledIn);
+                return null;
+            }
+            // 使用 "&" 进行拆分
+            String[] parts = str.split("&");
+            if (parts.length != 3) {
+                log.error("原材料条码格式不符合预期");
+                oledIn.setRemark("原材料条码格式不符合预期");
+                oledIn.setStatus("1");
+                insertOledIn(oledIn);
+                return null;
+            }
+            String goodsIdForUse = parts[0];
+
+            partInfo.setMaterial(goodsIdForUse);
+            partInfo.setItemDesc("原材料");
+            if ((partInfoMapper.selPartsByEqual(partInfo) == null || partInfoMapper.selPartsByEqual(partInfo).isEmpty()) && !Objects.equals(partInfo.getMaterial(), "YJRK0001")){
+                log.error("该原材料条码的物料号在数据库中不存在");
+                oledIn.setRemark("该原材料条码的物料号在数据库中不存在");
+                oledIn.setStatus("1");
+                insertOledIn(oledIn);
+                return null;
+            }
+            oledIn.setGoodsNum(parts[1]);
+            oledIn.setGoodsId(goodsIdForUse);
+            oledIn.setRemark("正常入库");
+            oledIn.setStatus("0");
+            insertOledIn(oledIn);
+            return request;
+        }else{
+            //发动机的情况
+            partInfo.setMaterial(request.getCodeMessage());
+            partInfo.setItemDesc("发动机");
+            if (partInfoMapper.selPartsByEqual(partInfo) == null || partInfoMapper.selPartsByEqual(partInfo).isEmpty()){
+                partInfo.setMaterial(request.getModel());
+                if (partInfoMapper.selPartsByEqual(partInfo) == null || partInfoMapper.selPartsByEqual(partInfo).isEmpty()){
+                    log.error("该机型在数据库中不存在");
+                    oledIn.setRemark("该机型在数据库中不存在");
+                    oledIn.setStatus("1");
+                    insertOledIn(oledIn);
+                    return null;
+                }else{
+                    //判断序列号在立库是否存在
+                    //判断入库任务和库存内，如果都没有就是对的
+                    Task taskQueryForGoodsId = new Task();
+                    taskQueryForGoodsId.setGoodsId(request.getCodeMessage());
+                    Stock stockQuery = new Stock();
+                    stockQuery.setGoodsId(request.getCodeMessage());
+                    List<Task> tasks = taskService.selTasks(taskQueryForGoodsId);
+                    List<Stock> stocks = stockMapper.selStocks(stockQuery);
+                    if ((tasks == null || tasks.isEmpty()) && (stocks == null || stocks.isEmpty())) {
+                        oledIn.setGoodsNum("1");
+                        oledIn.setGoodsId(request.getCodeMessage());
+                        oledIn.setModel(request.getModel());
+                        oledIn.setRemark("正常入库");
+                        oledIn.setStatus("0");
+                        insertOledIn(oledIn);
+                        return request;
+                    }else{
+                        log.error("该序列号已存在，请检查");
+                        oledIn.setGoodsNum("1");
+                        oledIn.setGoodsId(request.getCodeMessage());
+                        oledIn.setModel(request.getModel());
+                        oledIn.setRemark("该序列号已存在，请检查");
+                        oledIn.setStatus("1");
+                        insertOledIn(oledIn);
+                        return null;
+                    }
+                }
+            }else{
+                //判断序列号在立库是否存在
+                //判断入库任务和库存内，如果都没有就是对的
+                Task taskQueryForGoodsId = new Task();
+                taskQueryForGoodsId.setGoodsId(request.getCodeMessage());
+                Stock stockQuery = new Stock();
+                stockQuery.setGoodsId(request.getCodeMessage());
+                List<Task> tasks = taskService.selTasks(taskQueryForGoodsId);
+                List<Stock> stocks = stockMapper.selStocks(stockQuery);
+                if ((tasks == null || tasks.isEmpty()) && (stocks == null || stocks.isEmpty())) {
+                    // 使用多重赋值交换两个属性的值
+                    String temp = request.getModel();
+                    request.setModel(request.getCodeMessage());
+                    request.setCodeMessage(temp);
+                    oledIn.setGoodsNum("1");
+                    oledIn.setGoodsId(request.getCodeMessage());
+                    oledIn.setModel(request.getModel());
+                    oledIn.setRemark("正常入库");
+                    oledIn.setStatus("0");
+                    insertOledIn(oledIn);
+                    return request;
+                }else{
+                    String temp = request.getModel();
+                    request.setModel(request.getCodeMessage());
+                    request.setCodeMessage(temp);
+                    log.error("该序列号已存在，请检查");
+                    oledIn.setGoodsNum("1");
+                    oledIn.setGoodsId(request.getCodeMessage());
+                    oledIn.setModel(request.getModel());
+                    oledIn.setRemark("该序列号已存在，请检查");
+                    oledIn.setStatus("1");
+                    insertOledIn(oledIn);
+                    return null;
+                }
+
+
+
+            }
+        }
+    }
+
+    /**
+     * 立库申请入库
+     * @param request 请求信息
+     * @return 返回信息
+     */
+    @PostMapping("/requestIn")
+    public ResponseEntity requestIn(@RequestBody @Validated RequireInRequest request) {
+        try {
+            log.info(String.format("%s 点位请求入库：%s",request.getPoint(), request.getVehicleNo()));
+            //判断，如果config中状态为0或者1则不允许入库
+            List<Config> configs = configMapper.selectConfigs("100");
+            Config config = configs.get(0);
+            if (Objects.equals(config.getConfigValue(), "0") || Objects.equals(config.getConfigValue(), "1")){
+                log.info("当前一号入库口为出库和不可入模式，禁止入库！");
+                return new ResponseEntity(-1, "当前一号入库口为出库和不可入模式，禁止入库！");
+            }
+            //这里需要添加一个叠盘入库的请求，不需要判断额外条件，直接入库分配库位，记录库存即可
+            if (Objects.equals(request.getVehicleNo(), "D99999999")){//表示空托垛入库，不需要分辨warearea，只需要考虑5%剩余就可以了
+                //两个点位都有叠盘入库
+                if(request.getPoint().equals("244")) {//小托盘叠盘
+                    /* 查找一个空库位 */
+                    //每个巷道要留出5%的空库位用于移库，424（22），424，336（17）
+                    int[] tunnelIds = {1, 2, 3};
+                    int[] requiredEmptySlots = {22, 22, 17};
+                    int userId = 1;
+                    for (int i = 0; i < tunnelIds.length; i++) {
+                        try {
+                            int tunnelId = tunnelIds[i];
+                            int requiredSlots = requiredEmptySlots[i];
+
+                            Location useForKeepEmptyLocation = new Location();
+                            useForKeepEmptyLocation.setTunnelId(tunnelId);
+                            useForKeepEmptyLocation.setLocationStatus(0);
+
+                            List<Location> useForKeepEmptyLocations = locationMapper.selLocations(useForKeepEmptyLocation);
+                            int availableSlots = useForKeepEmptyLocations.size();
+
+                            if (availableSlots >= requiredSlots) {
+                                log.info("空托入库，巷道 {} 剩余空库位 {}，满足要求。", tunnelId, availableSlots);
+                                userId = tunnelId;
+                                break;
+                            } else {
+                                log.info("空托入库，巷道 {} 剩余空库位 {}，不足5%，尝试下一个巷道。", tunnelId, availableSlots);
+                            }
+                            if (tunnelId == 3){
+                                log.info("空托入库，所有巷道剩余空库位均不足5%，取消入库！");
+                                return new ResponseEntity(-1, String.format("没有多余空闲库位，取消入库，条码号：%s", request.getVehicleNo()));
+                            }
+                        } catch (Exception e) {
+                            log.error("空托入库，查询巷道 {} 空库位时发生错误：{}", tunnelIds[i], e.getMessage());
+                            return new ResponseEntity(-1, "查询空库位时发生错误");
+                        }
+                    }
+                    /* 查找一个空库位 */
+                    Location emptyLocation = new Location();
+                    emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+                    emptyLocation.setTunnelId(userId);
+                    List<Location> emptyLocations = locationMapper.selLocationsByDesc(emptyLocation);
+                    if(emptyLocations == null) {
+                        return new ResponseEntity(-1, "库位查找失败，网络连接异常，请稍后再试");
+                    }
+
+                    Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
+                    if(emptyLocationItem == null) {
+                        return new ResponseEntity(-1, "没有可用库位或者库位存在干涉，请稍后再试");
+                    }
+                    // 该空库位可用，生成一个入库任务，并将库存表更新库位
+                    // 更新库位表，占掉库位
+                    Location updateLocation = new Location();
+                    updateLocation.setLocationId(emptyLocationItem.getLocationId());
+                    updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+                    updateLocation.setVehicleId(request.getVehicleNo());
+                    locationMapper.modifyLocation(updateLocation); // 占掉库位
+                    // 添加入库任务
+                    Task taskByLitterEngine = new Task();
+                    taskByLitterEngine.setTaskId(UUID.randomUUID().toString());
+                    taskByLitterEngine.setTaskType(TaskType.IN.getCode());
+                    taskByLitterEngine.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                    taskByLitterEngine.setTaskGroup(UUID.randomUUID().toString());
+                    taskByLitterEngine.setOrigin(request.getPoint());
+                    taskByLitterEngine.setDestination(emptyLocationItem.getLocationId());
+                    taskByLitterEngine.setPickStand("小");//因为出库要选择不同的站台，要区分大小托盘，用这个字段来标记
+                    taskByLitterEngine.setWeight(0.0);
+                    taskByLitterEngine.setVehicleNo(request.getVehicleNo());
+                    taskByLitterEngine.setCreateTime(new Date());
+                    taskByLitterEngine.setUserName(null);
+                    taskByLitterEngine.setGoodsId(null);
+                    taskByLitterEngine.setGoodsName(null);
+                    taskByLitterEngine.setOperateNum(0);
+                    taskByLitterEngine.setTotalNum(0);
+                    taskByLitterEngine.setTaskPriority(1);
+                    taskByLitterEngine.setRemark1("空托垛入库");
+                    //开始向任务表中添加任务
+                    int addTask = taskMapper.addTask(taskByLitterEngine);
+                    if(addTask > 0) {
+                        return new ResponseEntity(0, "存在入库任务，申请成功");
+                    }
+                    return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
+                } else if (request.getPoint().equals("107")) {//大托盘叠盘
+                    /* 查找一个空库位 */
+                    Location emptyLocation = new Location();
+                    emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+                    emptyLocation.setTunnelId(3);
+                    List<Location> emptyLocations = locationMapper.selLocationsByDesc(emptyLocation);
+                    if(emptyLocations == null) {
+                        return new ResponseEntity(-1, "库位查找失败，网络连接异常，请稍后再试");
+                    }
+                    if (emptyLocations.size() < 17){
+                        return new ResponseEntity(-1, "空闲库位不足5%，取消入库");
+                    }
+
+                    Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
+                    if(emptyLocationItem == null) {
+                        return new ResponseEntity(-1, "没有可用库位或者库位存在干涉，请稍后再试");
+                    }
+                    // 该空库位可用，生成一个入库任务，并将库存表更新库位
+                    // 更新库位表，占掉库位
+                    Location updateLocation = new Location();
+                    updateLocation.setLocationId(emptyLocationItem.getLocationId());
+                    updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+                    updateLocation.setVehicleId(request.getVehicleNo());
+                    locationMapper.modifyLocation(updateLocation); // 占掉库位
+                    // 添加入库任务
+                    Task taskByLitterEngine = new Task();
+                    taskByLitterEngine.setTaskId(UUID.randomUUID().toString());
+                    taskByLitterEngine.setTaskType(TaskType.IN.getCode());
+                    taskByLitterEngine.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                    taskByLitterEngine.setTaskGroup(UUID.randomUUID().toString());
+                    taskByLitterEngine.setOrigin(request.getPoint());
+                    taskByLitterEngine.setDestination(emptyLocationItem.getLocationId());
+                    taskByLitterEngine.setPickStand("大");
+                    taskByLitterEngine.setWeight(0.0);
+                    taskByLitterEngine.setVehicleNo(request.getVehicleNo());
+                    taskByLitterEngine.setCreateTime(new Date());
+                    taskByLitterEngine.setUserName(null);
+                    taskByLitterEngine.setGoodsId(null);
+                    taskByLitterEngine.setGoodsName(null);
+                    taskByLitterEngine.setOperateNum(0);
+                    taskByLitterEngine.setTotalNum(0);
+                    taskByLitterEngine.setTaskPriority(1);
+                    taskByLitterEngine.setRemark1("空托垛入库");
+                    //开始向任务表中添加任务
+                    int addTask = taskMapper.addTask(taskByLitterEngine);
+                    if(addTask > 0) {
+                        return new ResponseEntity(0, "存在入库任务，申请成功");
+                    }
+                    return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
+                }
+            }
+
+            //处理条码信息
+            request = dealCodeInformation(request);
+            if (request == null){
+                log.error("条码错误，请查看日志！");
+                return new ResponseEntity(-1, "请检查任务监控中是否已存在此母托的任务，如果存在请清除。不存在请检查此任务的母托号、机型或物料号是否在数据库中");
+            }
+
+            //正常入库
+            //先根据点位判断是大托盘还是小托盘
+            //小托盘是201，228（存放发动机和原料），大托盘是101（仅存放原材料）
+            if(request.getPoint().equals("201") || request.getPoint().equals("228")) { //小托盘
+                //小托盘可以存放任意库位，但是还是按照123的顺序
+                /* 查找一个空库位 */
+                //客户要求原材料和成品分区存放，现设定成品为A，原材料为B
+                //所以找到wareArea为B的空闲库位
+                //每个巷道要留出5%的空库位用于移库，424（22），424，336（17）
+                // 随机选择1号或2号巷道
+                List<Integer> tunnelIds = Arrays.asList(1, 2);
+                Collections.shuffle(tunnelIds); // 随机打乱顺序
+                //int[] requiredEmptySlots = {22, 22, 17};
+                int usefullNum = 2;
+                List<Location> useForKeepEmptyLocations = null;
+                for (int tunnelId : tunnelIds) {
+                    //int requiredSlots = requiredEmptySlots[tunnelId - 1];
+                    Location useForKeepEmptyLocation = new Location();
+                    useForKeepEmptyLocation.setTunnelId(tunnelId);
+                    useForKeepEmptyLocation.setLocationStatus(0);
+                    useForKeepEmptyLocations = locationMapper.selLocations(useForKeepEmptyLocation);
+                    int availableSlots = useForKeepEmptyLocations.size();
+
+                    if (availableSlots >= 22) {
+                        log.info("小托盘入库，巷道 {} 剩余空库位 {}，满足要求。", tunnelId, availableSlots);
+                        break;
+                    } else {
+                        log.info("小托盘入库，巷道 {} 剩余空库位 {}，不足5%，尝试下一个巷道。", tunnelId, availableSlots);
+                        usefullNum = usefullNum - 1;
+                    }
+                }
+                // 如果1号和2号都不够，则选择3号
+                if (usefullNum == 0) {
+                    int tunnelId = 3;
+                    Location useForKeepEmptyLocation = new Location();
+                    useForKeepEmptyLocation.setTunnelId(tunnelId);
+                    useForKeepEmptyLocation.setLocationStatus(0);
+                    useForKeepEmptyLocations = locationMapper.selLocations(useForKeepEmptyLocation);
+                    int availableSlots = useForKeepEmptyLocations.size();
+                    if (availableSlots >= 17) {
+                        log.info("原材料3巷道入库，剩余空库位 {}，满足要求。", availableSlots);
+                    } else {
+                        log.info("原材料3巷道入库，所有巷道剩余空库位均不足5%，取消入库！");
+                        return new ResponseEntity(-1, String.format("没有多余空闲库位，取消入库，条码号：%s", request.getVehicleNo()));
+                    }
+                }
+                Location emptyLocationItem = locationUtils.checkCanUse(useForKeepEmptyLocations);
+                if(emptyLocationItem == null) {
+                    return new ResponseEntity(-1, "没有可用库位或者库位存在干涉，请稍后再试");
+                }
+                //先判断是发动机还是原料，有机型的是发动机，没有的是原料
+                if (request.getModel() == null || request.getModel().isEmpty()){//小托盘原材料
+                    //将codeMessage拆分
+                    String str = request.getCodeMessage();
+                    if (str == null || !str.contains("&")) {
+                        log.error("小托盘条码格式错误");
+                        return new ResponseEntity(-1, "请确认条码格式");
+                    }
+                    // 使用 "&" 进行拆分
+                    String[] parts = str.split("&");
+                    if (parts.length != 3) {
+                        log.error("小托盘条码格式不符合预期");
+                        return new ResponseEntity(-1, "请确认条码格式");
+                    }
+                    String goodsIdForUse = parts[0];
+                    int goodsNumForUse;
+                    String goodsDateForUse = parts[2];
+
+                    try {
+                        goodsNumForUse = Integer.parseInt(parts[1]);
+                    } catch (NumberFormatException e) {
+                        log.error("数量解析失败", e);
+                        return new ResponseEntity(-1, "数量解析失败，请确认条码格式");
+                    }
+                    LocalDate date;
+                    try {
+                        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
+                        date = LocalDate.parse(goodsDateForUse, formatter);
+                    } catch (DateTimeParseException e) {
+                        log.error("日期解析失败", e);
+                        return new ResponseEntity(-1, "日期解析失败，请确认条码格式");
+                    }
+                    // 该空库位可用，生成一个入库任务，并将库存表更新库位
+                    // 更新库位表，占掉库位
+                    Location updateLocation = new Location();
+                    updateLocation.setLocationId(emptyLocationItem.getLocationId());
+                    updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+                    updateLocation.setVehicleId(request.getVehicleNo());
+                    locationMapper.modifyLocation(updateLocation); // 占掉库位
+                    // 添加入库任务
+                    Task taskByLitterMaterial = new Task();
+                    taskByLitterMaterial.setTaskId(UUID.randomUUID().toString());
+                    taskByLitterMaterial.setTaskType(TaskType.IN.getCode());
+                    taskByLitterMaterial.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                    taskByLitterMaterial.setTaskGroup(UUID.randomUUID().toString());
+                    taskByLitterMaterial.setOrigin(request.getPoint());
+                    taskByLitterMaterial.setDestination(emptyLocationItem.getLocationId());
+                    taskByLitterMaterial.setPickStand("小");
+                    taskByLitterMaterial.setWeight(0.0);
+                    taskByLitterMaterial.setVehicleNo(request.getVehicleNo());
+                    taskByLitterMaterial.setCreateTime(new Date());
+                    taskByLitterMaterial.setUserName("原材料");
+                    taskByLitterMaterial.setGoodsId(goodsIdForUse);//后面要将codeMessage拆成物料码和数量
+                    taskByLitterMaterial.setOperateNum(goodsNumForUse);
+                    taskByLitterMaterial.setTotalNum(goodsNumForUse);
+                    taskByLitterMaterial.setTaskPriority(1);
+                    taskByLitterMaterial.setProductionDate(date);
+                    taskByLitterMaterial.setRemark1("原材料");
+                    //开始向任务表中添加任务
+                    int addTask = taskMapper.addTask(taskByLitterMaterial);
+                    if(addTask > 0) {
+                        return new ResponseEntity(0, "存在入库任务，申请成功");
+                    }
+                    return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
+                }else{//小托盘发动机
+                    //wcs会发两段过来，model作为机型，message作为序列号。其中卡特和柏金斯的发动机有区别，但是应该不影响
+                    // 在库存中查看是否存在该发动机序列号
+                    Stock queryStock = new Stock();
+                    queryStock.setBatchNo(request.getCodeMessage());
+                    List<Stock> selForBatchNoIsExist = stockService.selStocks(queryStock);
+                    if (!selForBatchNoIsExist.isEmpty()){
+                        return new ResponseEntity(-1, "该发动机序列号已经存在，无法入库！");
+                    }
+                    // 该空库位可用，生成一个入库任务，并将库存表更新库位
+                    // 更新库位表，占掉库位
+                    Location updateLocation = new Location();
+                    updateLocation.setLocationId(emptyLocationItem.getLocationId());
+                    updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+                    updateLocation.setVehicleId(request.getVehicleNo());
+                    locationMapper.modifyLocation(updateLocation); // 占掉库位
+                    // 添加入库任务
+                    Task taskByLitterEngine = new Task();
+                    taskByLitterEngine.setTaskId(UUID.randomUUID().toString());
+                    taskByLitterEngine.setTaskType(TaskType.IN.getCode());
+                    taskByLitterEngine.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                    taskByLitterEngine.setTaskGroup(UUID.randomUUID().toString());
+                    taskByLitterEngine.setOrigin(request.getPoint());
+                    taskByLitterEngine.setDestination(emptyLocationItem.getLocationId());
+                    //taskByLitterEngine.setDestination("A-03-11-D-4");
+                    taskByLitterEngine.setPickStand("小");
+                    taskByLitterEngine.setWeight(0.0);
+                    taskByLitterEngine.setVehicleNo(request.getVehicleNo());
+                    taskByLitterEngine.setCreateTime(new Date());
+                    taskByLitterEngine.setUserName("发动机成品");
+                    taskByLitterEngine.setGoodsId(request.getCodeMessage());//序列号
+                    taskByLitterEngine.setGoodsName(request.getModel());//机型
+                    taskByLitterEngine.setOperateNum(1);
+                    taskByLitterEngine.setTotalNum(1);
+                    taskByLitterEngine.setTaskPriority(1);
+                    taskByLitterEngine.setRemark1("成品");
+                    //开始向任务表中添加任务
+                    int addTask = taskMapper.addTask(taskByLitterEngine);
+                    if(addTask > 0) {
+                        return new ResponseEntity(0, "存在入库任务，申请成功");
+                    }
+                    return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
+                }
+            } else if (request.getPoint().equals("101") || request.getPoint().equals("104")) {//大托盘只能用于存放原材料
+                //大托盘只可以存放3巷道，且按照列倒序查找库位
+                //客户要求原材料和成品分区存放，现设定成品为A，原材料为B
+                //所以找到wareArea为B的空闲库位
+                //每个巷道要留出5%的空库位用于移库，424（22），424，336（17）
+                /* 查找一个空库位 */
+                Location emptyLocation = new Location();
+                emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
+                emptyLocation.setTunnelId(3);
+                List<Location> emptyLocations = locationMapper.selLocationsByDesc(emptyLocation);
+                if(emptyLocations == null) {
+                    return new ResponseEntity(-1, "库位查找失败，网络连接异常，请稍后再试");
+                }
+                if (emptyLocations.size() < 17){
+                    return new ResponseEntity(-1, "空闲库位不足5%，取消入库");
+                }
+//                List<Location> filteredLocations = emptyLocations.stream()
+//                        .filter(location -> "B".equals(location.getWareArea()))
+//                        .toList();
+//                if(filteredLocations.isEmpty()){
+//                    return new ResponseEntity(-1, "没有可用库位");
+//                }
+                Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
+                if(emptyLocationItem == null) {
+                    return new ResponseEntity(-1, "没有可用库位或者库位存在干涉，请稍后再试");
+                }
+                //将codeMessage拆分
+                String str = request.getCodeMessage();
+                if (str == null || !str.contains("&")) {
+                    log.error("条码格式错误");
+                    return new ResponseEntity(-1, "请确认条码格式");
+                }
+                // 使用 "&" 进行拆分
+                String[] parts = str.split("&");
+                if (parts.length != 3) {
+                    log.error("条码格式不符合预期");
+                    return new ResponseEntity(-1, "请确认条码格式");
+                }
+                String goodsIdForUse = parts[0];
+                int goodsNumForUse;
+                String goodsDateForUse = parts[2];
+
+                try {
+                    goodsNumForUse = Integer.parseInt(parts[1]);
+                } catch (NumberFormatException e) {
+                    log.error("数量解析失败", e);
+                    return new ResponseEntity(-1, "数量解析失败，请确认条码格式");
+                }
+                LocalDate date;
+                try {
+                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
+                    date = LocalDate.parse(goodsDateForUse, formatter);
+                } catch (DateTimeParseException e) {
+                    log.error("日期解析失败", e);
+                    return new ResponseEntity(-1, "日期解析失败，请确认条码格式");
+                }
+                // 该空库位可用，生成一个入库任务，并将库存表更新库位
+                // 更新库位表，占掉库位
+                Location updateLocation = new Location();
+                updateLocation.setLocationId(emptyLocationItem.getLocationId());
+                updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
+                updateLocation.setVehicleId(request.getVehicleNo());
+                locationMapper.modifyLocation(updateLocation); // 占掉库位
+                // 添加入库任务
+                Task taskByBigMaterial = new Task();
+                taskByBigMaterial.setTaskId(UUID.randomUUID().toString());
+                taskByBigMaterial.setTaskType(TaskType.IN.getCode());
+                taskByBigMaterial.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                taskByBigMaterial.setTaskGroup(UUID.randomUUID().toString());
+                taskByBigMaterial.setOrigin(request.getPoint());
+                taskByBigMaterial.setDestination(emptyLocationItem.getLocationId());
+                taskByBigMaterial.setPickStand("大");
+                taskByBigMaterial.setWeight(0.0);
+                taskByBigMaterial.setVehicleNo(request.getVehicleNo());
+                taskByBigMaterial.setCreateTime(new Date());
+                taskByBigMaterial.setUserName("原材料");
+                taskByBigMaterial.setGoodsId(goodsIdForUse);
+                taskByBigMaterial.setOperateNum(goodsNumForUse);
+                taskByBigMaterial.setTotalNum(goodsNumForUse);
+                taskByBigMaterial.setTaskPriority(1);
+                taskByBigMaterial.setProductionDate(date);
+                taskByBigMaterial.setRemark1("原材料");
+                //开始向任务表中添加任务
+                int addTask = taskMapper.addTask(taskByBigMaterial);
+                if(addTask > 0) {
+                    return new ResponseEntity(0, "存在入库任务，申请成功");
+                }
+                return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
+            }
+            return new ResponseEntity(999, "错误的入库点位" + request.getPoint(), null);
+        }catch (Exception e){
+            log.info("入库申请失败，出现异常，请稍后再试");
+            return new ResponseEntity(-1, "入库申请失败，网络连接异常，请稍后再试");
+        }
+    }
+
+    /**
+     * 收到 wcs 返回的任务状态
+     * @param wmsReceiveTaskResultEntity wcs请求值
+     * @return 返回的信息
+     */
+    @PostMapping("/sendTaskResult")
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public ResponseEntity receiveTaskResult(@RequestBody @Validated WmsReceiveTaskResultEntity wmsReceiveTaskResultEntity) {
+        try{
+            log.info("接收到任务反馈1：{}，ip地址：{}", wmsReceiveTaskResultEntity.toLoggerString(), HttpUtils.getIpAddr(servletRequest));
+            // 获取任务号
+            String taskId = wmsReceiveTaskResultEntity.getTaskId();
+            Integer taskStatus = wmsReceiveTaskResultEntity.getTaskStatus();
+            String vehicleNo = wmsReceiveTaskResultEntity.getVehicleNo();
+            if (taskId == null){
+                log.info("获取任务号失败");
+            }
+            log.info("获取任务号成功");
+            // 查找对应任务
+            Task taskForQuery = new Task();
+            taskForQuery.setTaskId(taskId);
+            List<Task> tasks = taskService.selTasks(taskForQuery);
+            if(tasks == null || tasks.isEmpty()) {
+                log.info("没有找到对应的任务");
+                return new ResponseEntity(-1, "没有找到对应的任务");
+            }
+            Task task = tasks.get(0);
+            if(taskStatus.equals(WmsTaskStatus.RUN.getCode())) { // 任务开始执行
+                log.info("任务开始执行");
+                return new ResponseEntity(0, "任务开始执行");
+            }
+            if(taskStatus.equals(WmsTaskStatus.FINISH.getCode())) { // 任务完成
+                boolean completedTask = taskOperation.completeTask(task);
+                if(!completedTask) {
+                    log.info("任务完成失败");
+                    return new ResponseEntity(-1, "任务完成失败，请稍后再试");
+                }
+                log.info("任务完成成功");
+                return new ResponseEntity(0, "任务完成成功");
+            }
+            if(taskStatus.equals(WmsTaskStatus.CANCEL.getCode())) { // 任务取消
+                boolean cancelledTask = taskOperation.cancelTask(task);
+                if(!cancelledTask) {
+                    return new ResponseEntity(-1, "任务取消失败，请稍后再试");
+                }
+                return new ResponseEntity(0, "任务取消成功");
+            }
+            log.info("不处理的状态");
+            return new ResponseEntity(0, "不处理的状态");
+        }catch (Exception e){
+            log.error("接收到任务反馈失败，ip地址：{}", HttpUtils.getIpAddr(servletRequest), e);
+            return new ResponseEntity(-1, "接收到任务反馈失败，请稍后再试");
+        }
+
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/main/java/com/wms/entity/BaseEntity.java

@@ -0,0 +1,9 @@
+package com.wms.entity;
+
+import com.alibaba.fastjson2.JSON;
+
+public class BaseEntity {
+    public String toLoggerString() {
+        return JSON.toJSONString(this);
+    }
+}

src/main/java/com/wms/entity/app/FinishPickTaskRequest.java

@@ -0,0 +1,139 @@
+package com.wms.entity.app;
+
+/**
+ * 完成当前载具拣货任务实体类
+ */
+public class FinishPickTaskRequest {
+    /**
+     * 任务id
+     */
+    private String taskId;
+    /**
+     * 卡特任务id
+     */
+    private String kateTaskId;
+    /**
+     * 料盒号
+     */
+    private String boxNo;
+    /**
+     * 零件号
+     */
+    private String partNo;
+    /**
+     * 需求/分配数量
+     */
+    private Integer needNum;
+    /**
+     * 实际库存
+     */
+    private Integer realNum;
+    /**
+     * 实际拣货数量
+     */
+    private Integer realPickNum;
+    /**
+     * 载具号
+     */
+    private String vehicleNo;
+    /**
+     * 出库数量
+     */
+    private Integer goodsNum;
+    /**
+     * 重量
+     */
+    private Double weight;
+    /**
+     * 拣选数量
+     */
+    private Integer pickNum;
+
+    public String getTaskId() {
+        return taskId;
+    }
+
+    public void setTaskId(String taskId) {
+        this.taskId = taskId;
+    }
+
+    public String getKateTaskId() {
+        return kateTaskId;
+    }
+
+    public void setKateTaskId(String kateTaskId) {
+        this.kateTaskId = kateTaskId;
+    }
+
+    public String getBoxNo() {
+        return boxNo;
+    }
+
+    public void setBoxNo(String boxNo) {
+        this.boxNo = boxNo;
+    }
+
+    public String getPartNo() {
+        return partNo;
+    }
+
+    public void setPartNo(String partNo) {
+        this.partNo = partNo;
+    }
+
+    public Integer getNeedNum() {
+        return needNum;
+    }
+
+    public void setNeedNum(Integer needNum) {
+        this.needNum = needNum;
+    }
+
+    public Integer getRealNum() {
+        return realNum;
+    }
+
+    public void setRealNum(Integer realNum) {
+        this.realNum = realNum;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public Integer getRealPickNum() {
+        return realPickNum;
+    }
+
+    public void setRealPickNum(Integer realPickNum) {
+        this.realPickNum = realPickNum;
+    }
+
+    public Integer getGoodsNum() {
+        return goodsNum;
+    }
+
+    public void setGoodsNum(Integer goodsNum) {
+        this.goodsNum = goodsNum;
+    }
+
+    public Double getWeight() {
+        return weight;
+    }
+
+    public void setWeight(Double weight) {
+        this.weight = weight;
+    }
+
+    public Integer getPickNum() {
+        return pickNum;
+    }
+
+    public void setPickNum(Integer pickNum) {
+        this.pickNum = pickNum;
+    }
+}

src/main/java/com/wms/entity/app/FinishVehicleAndPartRequest.java

@@ -0,0 +1,31 @@
+package com.wms.entity.app;
+
+/**
+ * 完成当前载具的当次拣货任务
+ */
+public class FinishVehicleAndPartRequest {
+    /**
+     * wms任务号
+     */
+    private String wmsTaskId;
+    /**
+     * 实际拣货数量
+     */
+    private Integer realPickNum;
+
+    public String getWmsTaskId() {
+        return wmsTaskId;
+    }
+
+    public void setWmsTaskId(String wmsTaskId) {
+        this.wmsTaskId = wmsTaskId;
+    }
+
+    public Integer getRealPickNum() {
+        return realPickNum;
+    }
+
+    public void setRealPickNum(Integer realPickNum) {
+        this.realPickNum = realPickNum;
+    }
+}

src/main/java/com/wms/entity/app/InventoryTask.java

@@ -0,0 +1,57 @@
+package com.wms.entity.app;
+
+import com.wms.entity.BaseEntity;
+
+/**
+ * 盘点任务信息
+ */
+public class InventoryTask extends BaseEntity {
+    /**
+     * 零件号
+     */
+    private String goodsId;
+    /**
+     * 料箱号
+     */
+    private String vehicleId;
+    /**
+     * 库区id
+     */
+    private String areaId;
+    /**
+     * 用户
+     */
+    private String userName;
+
+    public String getGoodsId() {
+        return goodsId;
+    }
+
+    public void setGoodsId(String goodsId) {
+        this.goodsId = goodsId;
+    }
+
+    public String getVehicleId() {
+        return vehicleId;
+    }
+
+    public void setVehicleId(String vehicleId) {
+        this.vehicleId = vehicleId;
+    }
+
+    public String getAreaId() {
+        return areaId;
+    }
+
+    public void setAreaId(String areaId) {
+        this.areaId = areaId;
+    }
+
+    public String getUserName() {
+        return userName;
+    }
+
+    public void setUserName(String userName) {
+        this.userName = userName;
+    }
+}

src/main/java/com/wms/entity/app/LayerLocation.java

@@ -0,0 +1,36 @@
+package com.wms.entity.app;
+
+import com.wms.entity.table.Location;
+
+import java.util.List;
+
+/**
+ * 按层划分的库位实体类
+ */
+public class LayerLocation {
+    /**
+     * 当前层
+     */
+    private Integer layer;
+
+    /**
+     * 当前层的所有库位
+     */
+    private List<Location> currentColLocations;
+
+    public Integer getLayer() {
+        return layer;
+    }
+
+    public void setLayer(Integer layer) {
+        this.layer = layer;
+    }
+
+    public List<Location> getCurrentColLocations() {
+        return currentColLocations;
+    }
+
+    public void setCurrentColLocations(List<Location> currentColLocations) {
+        this.currentColLocations = currentColLocations;
+    }
+}

src/main/java/com/wms/entity/app/MenuEntity.java

@@ -0,0 +1,70 @@
+package com.wms.entity.app;
+
+import java.util.List;
+
+public class MenuEntity {
+    /**
+     * 菜单Id
+     */
+    private String id;
+
+    /**
+     * 菜单名称
+     */
+    private String labelName;
+
+    /**
+     * 图标值
+     */
+    private String iconValue;
+
+    /**
+     * 地址
+     */
+    private String path;
+
+    /**
+     * 子菜单
+     */
+    private List<MenuEntity> children;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getLabelName() {
+        return labelName;
+    }
+
+    public void setLabelName(String labelName) {
+        this.labelName = labelName;
+    }
+
+    public String getIconValue() {
+        return iconValue;
+    }
+
+    public void setIconValue(String iconValue) {
+        this.iconValue = iconValue;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    public List<MenuEntity> getChildren() {
+        return children;
+    }
+
+    public void setChildren(List<MenuEntity> children) {
+        this.children = children;
+    }
+}

src/main/java/com/wms/entity/app/ResponseEntity.java

@@ -0,0 +1,62 @@
+package com.wms.entity.app;
+
+import com.wms.entity.BaseEntity;
+
+/**
+ * 接口响应实体类
+ */
+public class ResponseEntity extends BaseEntity {
+
+    public ResponseEntity(Integer code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+    public ResponseEntity(Integer code, String message, Object returnData) {
+        this.code = code;
+        this.message = message;
+        this.returnData = returnData;
+    }
+
+    public ResponseEntity() {
+    }
+
+    /**
+     * 响应代码
+     */
+    private Integer code;
+
+    /**
+     * 错误信息
+     */
+    private String message;
+
+    /**
+     * 返回数据（非必须）
+     */
+    private Object returnData;
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public void setCode(Integer code) {
+        this.code = code;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public Object getReturnData() {
+        return returnData;
+    }
+
+    public void setReturnData(Object returnData) {
+        this.returnData = returnData;
+    }
+}

src/main/java/com/wms/entity/app/RowLocation.java

@@ -0,0 +1,34 @@
+package com.wms.entity.app;
+
+import java.util.List;
+
+/**
+ * 排
+ */
+public class RowLocation {
+    /**
+     * 当前排
+     */
+    private Integer row;
+
+    /**
+     * 当前排的所有库位
+     */
+    private List<LayerLocation> currentLayerLocations;
+
+    public Integer getRow() {
+        return row;
+    }
+
+    public void setRow(Integer row) {
+        this.row = row;
+    }
+
+    public List<LayerLocation> getCurrentLayerLocations() {
+        return currentLayerLocations;
+    }
+
+    public void setCurrentLayerLocations(List<LayerLocation> currentLayerLocations) {
+        this.currentLayerLocations = currentLayerLocations;
+    }
+}

src/main/java/com/wms/entity/app/TaskInRequestEntity.java

@@ -0,0 +1,166 @@
+package com.wms.entity.app;
+
+import com.wms.entity.BaseEntity;
+
+import java.util.Date;
+
+/**
+ * WMS接收入库任务的接口实体类
+ */
+public class TaskInRequestEntity extends BaseEntity {
+    /**
+     * 物料编号
+     */
+    private String goodsId;
+
+    /**
+     * 批次号
+     */
+    private String batchNo;
+
+    /**
+     * 入库数量
+     */
+    private Integer goodsNum;
+
+    /**
+     * 入库日期/生产日期
+     */
+    private Date productionDate;
+
+    /**
+     * 托盘号
+     */
+    private String vehicleNo;
+
+    /**
+     * 尺寸
+     */
+    private Integer vehicleSize;
+
+    /**
+     * 重量
+     */
+    private Double weight;
+
+    /**
+     * 起始位置
+     */
+    private String origin;
+
+    /**
+     * 目标位置
+     */
+    private String destination;
+
+    /**
+     * 入库库位类型：是否为虚拟库位 0：虚拟库位；1：真实库位
+     */
+    private String isVirtual;
+
+    /**
+     * 是否空箱入库   0：空箱入库；1：带料入库
+     */
+    private String isEmpty;
+
+    /**
+     * 用户
+     */
+    private String userName;
+
+    public String getGoodsId() {
+        return goodsId;
+    }
+
+    public void setGoodsId(String goodsId) {
+        this.goodsId = goodsId;
+    }
+
+    public String getBatchNo() {
+        return batchNo;
+    }
+
+    public void setBatchNo(String batchNo) {
+        this.batchNo = batchNo;
+    }
+
+    public Integer getGoodsNum() {
+        return goodsNum;
+    }
+
+    public void setGoodsNum(Integer goodsNum) {
+        this.goodsNum = goodsNum;
+    }
+
+    public Date getProductionDate() {
+        return productionDate;
+    }
+
+    public void setProductionDate(Date productionDate) {
+        this.productionDate = productionDate;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public Double getWeight() {
+        return weight;
+    }
+
+    public void setWeight(Double weight) {
+        this.weight = weight;
+    }
+
+    public String getOrigin() {
+        return origin;
+    }
+
+    public void setOrigin(String origin) {
+        this.origin = origin;
+    }
+
+    public String getDestination() {
+        return destination;
+    }
+
+    public void setDestination(String destination) {
+        this.destination = destination;
+    }
+
+    public Integer getVehicleSize() {
+        return vehicleSize;
+    }
+
+    public void setVehicleSize(Integer vehicleSize) {
+        this.vehicleSize = vehicleSize;
+    }
+
+    public String getIsVirtual() {
+        return isVirtual;
+    }
+
+    public void setIsVirtual(String isVirtual) {
+        this.isVirtual = isVirtual;
+    }
+
+    public String getIsEmpty() {
+        return isEmpty;
+    }
+
+    public void setIsEmpty(String isEmpty) {
+        this.isEmpty = isEmpty;
+    }
+
+    public String getUserName() {
+        return userName;
+    }
+
+    public void setUserName(String userName) {
+        this.userName = userName;
+    }
+}

src/main/java/com/wms/entity/app/TaskOutRequestEntity.java

@@ -0,0 +1,57 @@
+package com.wms.entity.app;
+
+import com.wms.entity.BaseEntity;
+
+/**
+ * 前台向后台发送出库请求实体类
+ */
+public class TaskOutRequestEntity extends BaseEntity {
+    /**
+     * 物料编号
+     */
+    private String goodsId;
+    /**
+     * 需求数量
+     */
+    private Integer needNum;
+    /**
+     * 载具编号
+     */
+    private String vehicleNo;
+    /**
+     * 用户名称
+     */
+    private String userName;
+
+    public String getGoodsId() {
+        return goodsId;
+    }
+
+    public void setGoodsId(String goodsId) {
+        this.goodsId = goodsId;
+    }
+
+    public Integer getNeedNum() {
+        return needNum;
+    }
+
+    public void setNeedNum(Integer needNum) {
+        this.needNum = needNum;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public String getUserName() {
+        return userName;
+    }
+
+    public void setUserName(String userName) {
+        this.userName = userName;
+    }
+}

src/main/java/com/wms/entity/app/UserConfigEntity.java

@@ -0,0 +1,34 @@
+package com.wms.entity.app;
+
+import com.wms.entity.table.User;
+import com.wms.entity.BaseEntity;
+
+import java.util.List;
+
+public class UserConfigEntity extends BaseEntity {
+    /**
+     * 用户认证信息
+     */
+    private User user;
+
+    /**
+     * 菜单及各种按钮信息
+     */
+    private List<MenuEntity> menuList;
+
+    public User getUser() {
+        return user;
+    }
+
+    public void setUser(User user) {
+        this.user = user;
+    }
+
+    public List<MenuEntity> getMenuList() {
+        return menuList;
+    }
+
+    public void setMenuList(List<MenuEntity> menuList) {
+        this.menuList = menuList;
+    }
+}

src/main/java/com/wms/entity/app/container/ContainerApiLocalResponse.java

@@ -0,0 +1,42 @@
+package com.wms.entity.app.container;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * 给四向车服务的通用返回类
+ */
+@Data
+public class ContainerApiLocalResponse {
+
+    public ContainerApiLocalResponse(String code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+    public ContainerApiLocalResponse(String code, String wmsTaskId, String message) {
+        this.code = code;
+        this.wmsTaskId = wmsTaskId;
+        this.message = message;
+    }
+
+    /**
+     * 响应代码
+     */
+    @JsonProperty("code")
+    private String code;
+
+    /**
+     * wms 任务号
+     */
+    @JsonProperty("wmstaskid")
+    private String wmsTaskId;
+
+    /**
+     * 响应信息
+     */
+    @JsonProperty("message")
+    private String message;
+
+
+}

src/main/java/com/wms/entity/app/container/CreateInstoreTaskRequest.java

@@ -0,0 +1,56 @@
+package com.wms.entity.app.container;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+
+/**
+ * 四向车扫码入库的请求
+ */
+@Data
+public class CreateInstoreTaskRequest {
+
+    /**
+     * 请求号
+     */
+    @NotBlank(message = "请求号不允许为空")
+    @JsonProperty("requestid")
+    private String requestId;
+
+    /**
+     * 密钥
+     */
+    @NotBlank(message = "密钥不允许为空")
+    @JsonProperty("key")
+    private String key;
+
+    /**
+     * 托盘号
+     */
+    @NotBlank(message = "托盘号不允许为空")
+    @JsonProperty("palletno")
+    private String palletNo;
+
+    /**
+     * 长
+     */
+    @Pattern(regexp = "^\\d+$", message = "长不允许为空或者为非数字")
+    @JsonProperty("height")
+    private String height;
+
+    /**
+     * 宽
+     */
+    @Pattern(regexp = "^\\d+$", message = "宽不允许为空或者为非数字")
+    @JsonProperty("weight")
+    private String weight;
+
+    /**
+     * 起点位置
+     */
+    @NotBlank(message = "起点位置不允许为空")
+    @JsonProperty("fromcellno")
+    private String fromCellNo;
+
+}

src/main/java/com/wms/entity/app/container/CreateInstoreTaskResponse.java

@@ -0,0 +1,57 @@
+package com.wms.entity.app.container;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * 四向车扫码入库的接口的返回响应
+ */
+@Data
+public class CreateInstoreTaskResponse {
+
+    public CreateInstoreTaskResponse(String code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+    public CreateInstoreTaskResponse() {
+    }
+
+    /**
+     * 响应代码
+     */
+    @JsonProperty("code")
+    private String code;
+
+    /**
+     * wms 任务号
+     */
+    @JsonProperty("wmstaskid")
+    private String wmsTaskId;
+
+    /**
+     * 载具号
+     */
+    @JsonProperty("palletno")
+    private String palletNo;
+
+    /**
+     * 起始位置
+     */
+    @JsonProperty("fromcellno")
+    private String fromCellNo;
+
+    /**
+     * 目的位置
+     */
+    @JsonProperty("tocellno")
+    private String toCellNo;
+
+    /**
+     * 信息
+     */
+    @JsonProperty("message")
+    private String message;
+
+
+}

src/main/java/com/wms/entity/app/container/SendContainerTaskRequest.java

@@ -0,0 +1,57 @@
+package com.wms.entity.app.container;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * 发送四向车任务的请求类
+ */
+@Data
+public class SendContainerTaskRequest {
+
+    /**
+     * 请求号
+     */
+    @JsonProperty("requestid")
+    private String requestid;
+
+    /**
+     * 秘钥
+     */
+    @JsonProperty("key")
+    private String key;
+
+    /**
+     * wms任务号
+     */
+    @JsonProperty("wmstaskid")
+    private String wmstaskid;
+
+    /**
+     * 容器号
+     */
+    @JsonProperty("palletno")
+    private String palletno;
+
+    /**
+     * 源点
+     */
+    @JsonProperty("fromcellno")
+    private String fromcellno;
+
+    /**
+     * 目的点
+     */
+    @JsonProperty("tocellno")
+    private String tocellno;
+
+    /**
+     * 任务类型
+     */
+    @JsonProperty("tasktype")
+    private String tasktype;
+
+
+
+
+}

src/main/java/com/wms/entity/app/container/TaskStateNoticeRequest.java

@@ -0,0 +1,39 @@
+package com.wms.entity.app.container;
+
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+@Data
+public class TaskStateNoticeRequest {
+
+    /**
+     * 请求ID
+     */
+    @NotBlank
+    @JsonProperty("requestid")
+    private String requestId;
+
+    /**
+     * 密钥
+     */
+    @NotBlank
+    @JsonProperty("key")
+    private String key;
+
+    /**
+     * wms任务号
+     */
+    @NotBlank
+    @JsonProperty("wmstaskid")
+    private String wmsTaskId;
+
+    /**
+     * 任务状态
+     */
+    @NotBlank
+    @JsonProperty("taskstate")
+    private String taskState;
+
+}

src/main/java/com/wms/entity/app/display/LocationData.java

@@ -0,0 +1,55 @@
+package com.wms.entity.app.display;
+
+/**
+ * 大屏用数据详细类
+ */
+public class LocationData {
+    /**
+     * 零件号
+     */
+    private String goodsId;
+    /**
+     * 零件名称
+     */
+    private String goodsName;
+    /**
+     * 数量
+     */
+    private Integer goodsNum;
+    /**
+     * 备注
+     */
+    private String remark;
+
+    public String getGoodsId() {
+        return goodsId;
+    }
+
+    public void setGoodsId(String goodsId) {
+        this.goodsId = goodsId;
+    }
+
+    public String getGoodsName() {
+        return goodsName;
+    }
+
+    public void setGoodsName(String goodsName) {
+        this.goodsName = goodsName;
+    }
+
+    public Integer getGoodsNum() {
+        return goodsNum;
+    }
+
+    public void setGoodsNum(Integer goodsNum) {
+        this.goodsNum = goodsNum;
+    }
+
+    public String getRemark() {
+        return remark;
+    }
+
+    public void setRemark(String remark) {
+        this.remark = remark;
+    }
+}

src/main/java/com/wms/entity/app/display/LocationInfo.java

@@ -0,0 +1,45 @@
+package com.wms.entity.app.display;
+
+import java.util.List;
+
+/**
+ * 大屏用库位信息
+ */
+public class LocationInfo {
+    /**
+     * 库位编号
+     */
+    private String locationId;
+    /**
+     * 料箱号
+     */
+    private String vehicleNo;
+    /**
+     * 详细数据
+     */
+    private List<LocationData> locationData;
+
+    public String getLocationId() {
+        return locationId;
+    }
+
+    public void setLocationId(String locationId) {
+        this.locationId = locationId;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public List<LocationData> getLocationData() {
+        return locationData;
+    }
+
+    public void setLocationData(List<LocationData> locationData) {
+        this.locationData = locationData;
+    }
+}

src/main/java/com/wms/entity/app/mes/CheckNoticeRequest.java

@@ -0,0 +1,35 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/**
+ * 盘点通知单请求类
+ */
+@Data
+public class CheckNoticeRequest {
+
+    /**
+     * 唯一识别码
+     */
+    @JsonProperty("guid")
+    @NotBlank(message = "唯一识别码不允许为空或者空字符串")
+    private String guid;
+
+    /**
+     * 盘点单号
+     */
+    @JsonProperty("InventoryNo")
+    @NotBlank(message = "盘点单号不允许为空或者空字符串")
+    private String inventoryNo;
+
+    /**
+     * 盘点库别
+     */
+    @JsonProperty("IWarehouse")
+    @NotBlank(message = "盘点库别不允许为空或者空字符串")
+    private String iWarehouse;
+
+
+}

src/main/java/com/wms/entity/app/mes/MesApiLocalResponse.java

@@ -0,0 +1,29 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * mes 接口的返回类，本地响应给 Mes 用的
+ */
+@Data
+public class MesApiLocalResponse {
+
+    public MesApiLocalResponse(Integer transFlag, String errorMessage) {
+        this.transFlag = transFlag;
+        this.errorMessage = errorMessage;
+    }
+
+    /**
+     * 响应编号：1 - 成功；0 - 失败
+     */
+    @JsonProperty("TransFlag")
+    private Integer transFlag;
+
+    /**
+     * 返回的信息
+     */
+    @JsonProperty("ErrorMessage")
+    private String errorMessage;
+
+}

src/main/java/com/wms/entity/app/mes/OutNoticeRequest.java

@@ -0,0 +1,68 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * Mes 出货通单请求信息
+ */
+@Data
+public class OutNoticeRequest {
+
+    /**
+     * 唯一识别码
+     */
+    @NotBlank(message = "唯一识别码不允许为空或者空字符串")
+    @JsonProperty("guid")
+    private String guid;
+
+    /**
+     * 出库通知单号
+     */
+    @NotBlank(message = "发货通知单不允许为空或者空字符串")
+    @JsonProperty("TransferNo")
+    private String transferNo;
+
+    /**
+     * 源库别
+     */
+    @NotBlank(message = "源库别不允许为空或者空字符串")
+    @JsonProperty("FWarehouse")
+    private String fWarehouse;
+
+    /**
+     * 目的库别
+     */
+    //@NotBlank(message = "目的库别不允许为空或者空字符串")
+    @JsonProperty("Twarehouse")
+    private String tWarehouse;
+
+    /**
+     * 出库类型
+     */
+    @NotNull(message = "类型不允许为空")
+    @JsonProperty("Type")
+    private Integer type;
+
+
+    /**
+     * 计划交货日期
+     */
+    @NotBlank(message = "计划交货日不允许为空或者空字符串")
+    @JsonProperty("RDate")
+    private String rDate;
+
+    /**
+     * 行信息
+     */
+    @NotEmpty(message = "行信息不允许为空")
+    @JsonProperty("Row")
+    private OutNoticeRequestRow[] row;
+
+}

src/main/java/com/wms/entity/app/mes/OutNoticeRequestRow.java

@@ -0,0 +1,47 @@
+package com.wms.entity.app.mes;
+
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+
+/**
+ * 发货通知单行信息
+ */
+@Data
+public class OutNoticeRequestRow {
+
+    /**
+     * 行号
+     */
+    @Pattern(regexp = "^\\d+$", message = "行号必须为数字")
+    @JsonProperty("TransferLine")
+    private String transferLine;
+
+    /**
+     * 料号
+     */
+    @NotBlank(message = "料号不允许为空或者空字符串")
+    @JsonProperty("ItemCode")
+    private String itemCode;
+
+    /**
+     * 数量??????
+     */
+    //@Pattern(regexp = "^\\\\d*(\\\\.\\\\d+)?$", message = "数量必须为数字")
+    //@Pattern(regexp = "^\\d+$", message = "数量必须为数字")
+    @JsonProperty("Qty")
+    private String qty;
+//    @Pattern(regexp = ".*", message = "数量必须为字符串")
+//    @JsonProperty("Qty")
+//    private String qty;
+
+
+    /**
+     * 单位
+     */
+    @NotBlank(message = "单位不允许为空或者空字符串")
+    @JsonProperty("Unit")
+    private String unit;
+}

src/main/java/com/wms/entity/app/mes/ReceiptInRequest.java

@@ -0,0 +1,71 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+
+/**
+ * Mes 推送入库信息的实体
+ */
+@Data
+public class ReceiptInRequest {
+
+    /**
+     * 唯一识别码
+     */
+    @JsonProperty("guid")
+    @NotBlank(message = "唯一识别码不允许为空或者空字符串")
+    private String guid;
+
+    /**
+     * 入库类型
+     * 1-原料入库
+     * 2-半成品入库
+     * 3-成品入库
+     * 4-销售退货入库
+     * 5-其他入库
+     */
+    @JsonProperty("Type")
+    @NotNull(message = "入库类型不允许为空")
+    private Integer type;
+
+    /**
+     * 批次号
+     */
+    @JsonProperty("Losnr")
+    //@NotBlank(message = "批次号不允许为空")
+    public String losnr;
+
+    /**
+     * 载具号
+     */
+    @JsonProperty("VehicleNo")
+    public String vehicleNo;
+
+    /**
+     * 料号
+     */
+    @JsonProperty("ItemCode")
+    @NotBlank(message = "料号不允许为空")
+    public String itemCode;
+
+    /**
+     * 数量
+     */
+    @JsonProperty("LotQty")
+    @NotNull(message = "数量不允许为空")
+    //@Pattern(regexp = "^\\d+$", message = "数量必须为数字")
+    //@Pattern(regexp = "^\\\\d*(\\\\.\\\\d+)?$", message = "数量必须为数字")
+    //@Pattern(regexp = "^\\d*(\\.\\d+)?$", message = "数量必须为有效的数字字符串")
+    public String lotQty;
+
+    /**
+     * 库别
+     */
+    @JsonProperty("Warehouse")
+    @NotBlank(message = "库别不允许为空")
+    public String warehouse;
+
+}

src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRequest.java

@@ -0,0 +1,26 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 发送mes 盘点执行
+ */
+@Data
+public class SendMesGoodsInventoryRequest {
+
+    @JsonProperty("guid")
+    private String guid;
+
+    @JsonProperty("InventoryNo")
+    private String inventoryNo;
+
+    @JsonProperty("Row")
+    private List<SendMesGoodsInventoryRow> row;
+
+
+}
+
+

src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRow.java

@@ -0,0 +1,20 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+
+@Data
+public class SendMesGoodsInventoryRow {
+
+    @JsonProperty("Losnr")
+    private String losnr;
+
+    @JsonProperty("LotQty")
+    private String lotQty;
+
+    @JsonProperty("Warehouse")
+    private String warehouse;
+
+
+}

src/main/java/com/wms/entity/app/mes/SendMesGoodsMoveRequest.java

@@ -0,0 +1,29 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * 发送mes移库完成
+ */
+@Data
+public class SendMesGoodsMoveRequest {
+
+    @JsonProperty("guid")
+    private String guid;
+
+    @JsonProperty("Losnr")
+    private String losnr;
+
+    @JsonProperty("LotQty")
+    private String lotQty;
+
+    @JsonProperty("FBinCOde")
+    private String fBinCode;
+
+    @JsonProperty("TBinCode")
+    private String tBinCode;
+
+
+
+}

src/main/java/com/wms/entity/app/mes/SendMesPutInGoodsRequest.java

@@ -0,0 +1,43 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * 入库发送 mes
+ */
+@Data
+public class SendMesPutInGoodsRequest {
+
+    /**
+     * 唯一号
+     */
+    @JsonProperty("guid")
+    private String guid;
+
+    /**
+     * 批次号
+     */
+    @JsonProperty("Losnr")
+    private String losnr;
+
+    /**
+     * 料号
+     */
+    @JsonProperty("ItemCode")
+    private String itemCode;
+
+    /**
+     * 数量
+     */
+    @JsonProperty("LotQty")
+    private String lotQty;
+
+    /**
+     * 库位
+     */
+    @JsonProperty("BinCode")
+    private String binCode;
+
+
+}

src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRequest.java

@@ -0,0 +1,27 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 发送mes出库信息
+ */
+@Data
+public class SendMesPutOutGoodsRequest {
+
+    @JsonProperty("guid")
+    private String guid;
+
+    @JsonProperty("TransferNo")
+    private String transferNo;
+
+    @JsonProperty("Type")
+    private int type;
+
+    @JsonProperty("Row")
+    private List<SendMesPutOutGoodsRow> row;
+
+
+}

src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRow.java

@@ -0,0 +1,31 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class SendMesPutOutGoodsRow {
+
+    //行号
+    @JsonProperty("TransferLine")
+    private String transferLine;
+
+    //批次
+    @JsonProperty("Losnr")
+    private String losnr;
+
+    //数量
+    @JsonProperty("LotQty")
+    private String lotQty;
+
+    //箱号
+    @JsonProperty("VehicleNo")
+    private String vehicleNo;
+
+    //仓库
+    @JsonProperty("Warehouse")
+    private String warehouse;
+
+
+
+}

src/main/java/com/wms/entity/app/mes/SendMesStockRequest.java

@@ -0,0 +1,32 @@
+package com.wms.entity.app.mes;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class SendMesStockRequest {
+
+    @JsonProperty("guid")
+    private String guid;
+
+    @JsonProperty("Warehouse")
+    private String Warehouse;
+
+    @JsonProperty("ItemCode")
+    private String ItemCode;
+
+    @JsonProperty("Losnr")
+    private String Losnr;
+
+    @JsonProperty("LotQty")
+    private String LotQty;
+
+    @JsonProperty("Unit")
+    private String Unit;
+
+    @JsonProperty("BinCode")
+    private String BinCode;
+
+    @JsonProperty("VehicleNo")
+    private String VehicleNo;
+}

src/main/java/com/wms/entity/app/vo/FileVo.java

@@ -0,0 +1,23 @@
+package com.wms.entity.app.vo;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * 文件Vo
+ */
+@Data
+public class FileVo {
+    @JsonProperty("fileId")
+    private String fileId;
+    @JsonProperty("name")
+    private String name;
+    @JsonProperty("type")
+    private String type;
+    @JsonProperty("size")
+    private String size;
+    @JsonProperty("hash")
+    private String hash;
+    @JsonProperty("userName")
+    private String userName;
+}

src/main/java/com/wms/entity/app/vo/RoleOption.java

@@ -0,0 +1,31 @@
+package com.wms.entity.app.vo;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.wms.entity.table.Role;
+import lombok.Data;
+
+@Data
+public class RoleOption {
+    /**
+     * 标签
+     */
+    @JsonProperty("label")
+    private String label;
+    /**
+     * 值
+     */
+    @JsonProperty("value")
+    private Integer value;
+
+    /**
+     * 将角色对象转化为角色选项对象
+     * @param role 角色
+     * @return 结果
+     */
+    public static RoleOption of(Role role) {
+        RoleOption roleOption = new RoleOption();
+        roleOption.setLabel(role.getRoleName());
+        roleOption.setValue(role.getRoleId());
+        return roleOption;
+    }
+}

src/main/java/com/wms/entity/app/wcs/DisposeStandRequest.java

@@ -0,0 +1,40 @@
+package com.wms.entity.app.wcs;
+
+public class DisposeStandRequest {
+    /**
+     * 站台
+     */
+    private String pickStand;
+    /**
+     * 载具号
+     */
+    private String vehicleNo;
+    /**
+     * 状态
+     */
+    private Integer status;
+
+    public String getPickStand() {
+        return pickStand;
+    }
+
+    public void setPickStand(String pickStand) {
+        this.pickStand = pickStand;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public Integer getStatus() {
+        return status;
+    }
+
+    public void setStatus(Integer status) {
+        this.status = status;
+    }
+}

src/main/java/com/wms/entity/app/wcs/PickTaskRequest.java

@@ -0,0 +1,45 @@
+package com.wms.entity.app.wcs;
+
+import java.util.List;
+
+/**
+ * WCS上报箱子到达接口请求
+ */
+public class PickTaskRequest {
+    /**
+     * 载具号
+     */
+    private String vehicleNo;
+    /**
+     * 拣选站台
+     */
+    private List<String> pickStand;
+    /**
+     * 备注
+     */
+    private String remark;
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public List<String> getPickStand() {
+        return pickStand;
+    }
+
+    public void setPickStand(List<String> pickStand) {
+        this.pickStand = pickStand;
+    }
+
+    public String getRemark() {
+        return remark;
+    }
+
+    public void setRemark(String remark) {
+        this.remark = remark;
+    }
+}

src/main/java/com/wms/entity/app/wcs/PickTaskResponse.java

@@ -0,0 +1,40 @@
+package com.wms.entity.app.wcs;
+
+public class PickTaskResponse {
+    /**
+     * 载具号
+     */
+    private String vehicleNo;
+    /**
+     * 拣选站台
+     */
+    private String pickStand;
+    /**
+     * 备注
+     */
+    private String remark;
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public String getPickStand() {
+        return pickStand;
+    }
+
+    public void setPickStand(String pickStand) {
+        this.pickStand = pickStand;
+    }
+
+    public String getRemark() {
+        return remark;
+    }
+
+    public void setRemark(String remark) {
+        this.remark = remark;
+    }
+}

src/main/java/com/wms/entity/app/wcs/RequireInRequest.java

@@ -0,0 +1,34 @@
+package com.wms.entity.app.wcs;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/**
+ * WCS请求载具入库 实体类
+ */
+@Data
+public class RequireInRequest {
+    /**
+     * 点位
+     */
+    @NotBlank(message = "请求的点位不能为空")
+    private String point;
+    /**
+     * 载具编号
+     */
+    @NotBlank(message = "请求的载具编号不能为空")
+    private String vehicleNo;
+    /**
+     * 条码信息
+     */
+    private String codeMessage;
+    /**
+     * 机型
+     */
+    private String model;
+    /**
+     * 备注
+     */
+    private String remark;
+
+}

src/main/java/com/wms/entity/app/wcs/RequireOutRequest.java

@@ -0,0 +1,13 @@
+package com.wms.entity.app.wcs;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+@Data
+public class RequireOutRequest {
+    /**
+     * 点位
+     */
+    @NotBlank(message = "请求的点位不能为空")
+    private String point;
+}

src/main/java/com/wms/entity/app/wcs/WcsGoods.java

@@ -0,0 +1,83 @@
+package com.wms.entity.app.wcs;
+
+import com.wms.entity.BaseEntity;
+
+import java.math.BigDecimal;
+
+/**
+ * wcs需要的物料信息
+ */
+public class WcsGoods extends BaseEntity {
+    /**
+     * 物品编号
+     */
+    private String goodsId;
+    /**
+     * 物品名称
+     */
+    private String goodsName;
+    /**
+     * 物品批次
+     */
+    private String batch;
+    /**
+     * 物品条码
+     */
+    private String goodsCode;
+    /**
+     * 物品单位
+     */
+    private String unit;
+    /**
+     * 物品数量
+     */
+    private BigDecimal goodsNum;
+
+    public String getGoodsId() {
+        return goodsId;
+    }
+
+    public void setGoodsId(String goodsId) {
+        this.goodsId = goodsId;
+    }
+
+    public String getGoodsName() {
+        return goodsName;
+    }
+
+    public void setGoodsName(String goodsName) {
+        this.goodsName = goodsName;
+    }
+
+    public String getBatch() {
+        return batch;
+    }
+
+    public void setBatch(String batch) {
+        this.batch = batch;
+    }
+
+    public String getGoodsCode() {
+        return goodsCode;
+    }
+
+    public void setGoodsCode(String goodsCode) {
+        this.goodsCode = goodsCode;
+    }
+
+    public String getUnit() {
+        return unit;
+    }
+
+    public void setUnit(String unit) {
+        this.unit = unit;
+    }
+
+    public BigDecimal getGoodsNum() {
+        return goodsNum;
+    }
+
+    public void setGoodsNum(BigDecimal goodsNum) {
+        this.goodsNum = goodsNum;
+    }
+}

src/main/java/com/wms/entity/app/wcs/WcsTask.java

@@ -0,0 +1,152 @@
+package com.wms.entity.app.wcs;
+
+import com.wms.entity.BaseEntity;
+
+/**
+ * WMS向WCS发送任务请求的实体类
+ */
+public class WcsTask extends BaseEntity {
+
+    /**
+     * 任务编号
+     */
+    private String taskId;
+
+    /**
+     * 任务类型
+     */
+    private Integer taskType;
+
+    /**
+     * 优先级
+     */
+    private Integer priority;
+
+    /**
+     * 任务状态
+     */
+    private Integer taskStatus;
+
+    /**
+     * 起点
+     */
+    private String origin;
+
+    /**
+     * 任务中间点
+     */
+    private String midPoint;
+
+    /**
+     * 终点
+     */
+    private String destination;
+
+    /**
+     * 载具编号
+     */
+    private String vehicleNo;
+
+    /**
+     * 载具尺寸
+     */
+    private Integer vehicleSize;
+
+    /**
+     * 重量
+     */
+    private Double weight;
+
+    /**
+     * 信息---一般填异常信息
+     */
+    private String message;
+
+    public String getTaskId() {
+        return taskId;
+    }
+
+    public void setTaskId(String taskId) {
+        this.taskId = taskId;
+    }
+
+    public Integer getTaskType() {
+        return taskType;
+    }
+
+    public void setTaskType(Integer taskType) {
+        this.taskType = taskType;
+    }
+
+    public Integer getPriority() {
+        return priority;
+    }
+
+    public void setPriority(Integer priority) {
+        this.priority = priority;
+    }
+
+    public Integer getTaskStatus() {
+        return taskStatus;
+    }
+
+    public void setTaskStatus(Integer taskStatus) {
+        this.taskStatus = taskStatus;
+    }
+
+    public String getOrigin() {
+        return origin;
+    }
+
+    public void setOrigin(String origin) {
+        this.origin = origin;
+    }
+
+    public String getMidPoint() {
+        return midPoint;
+    }
+
+    public void setMidPoint(String midPoint) {
+        this.midPoint = midPoint;
+    }
+
+    public String getDestination() {
+        return destination;
+    }
+
+    public void setDestination(String destination) {
+        this.destination = destination;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public Integer getVehicleSize() {
+        return vehicleSize;
+    }
+
+    public void setVehicleSize(Integer vehicleSize) {
+        this.vehicleSize = vehicleSize;
+    }
+
+    public Double getWeight() {
+        return weight;
+    }
+
+    public void setWeight(Double weight) {
+        this.weight = weight;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+}

src/main/java/com/wms/entity/app/wcs/WcsToWmsInspectVesselEntity.java

@@ -0,0 +1,102 @@
+package com.wms.entity.app.wcs;
+
+import com.wms.entity.BaseEntity;
+
+import java.math.BigDecimal;
+
+/**
+ * WCS向WMS发送容器信息的实体类
+ */
+public class WcsToWmsInspectVesselEntity extends BaseEntity {
+
+    /**
+     * 请求时间
+     */
+    private String requestTime;
+
+    /**
+     * 任务类型
+     */
+    private Integer taskType;
+
+    /**
+     * 载具编号
+     */
+    private String vehicleNo;
+
+    /**
+     * 设备编号
+     */
+    private Integer equipmentId;
+
+    /**
+     * 地点
+     */
+    private String place;
+
+    /**
+     * 尺寸
+     */
+    private Integer size;
+
+    /**
+     * 重量
+     */
+    private BigDecimal weight;
+
+    public String getRequestTime() {
+        return requestTime;
+    }
+
+    public void setRequestTime(String requestTime) {
+        this.requestTime = requestTime;
+    }
+
+    public Integer getTaskType() {
+        return taskType;
+    }
+
+    public void setTaskType(Integer taskType) {
+        this.taskType = taskType;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public String getPlace() {
+        return place;
+    }
+
+    public void setPlace(String place) {
+        this.place = place;
+    }
+
+    public Integer getSize() {
+        return size;
+    }
+
+    public void setSize(Integer size) {
+        this.size = size;
+    }
+
+    public BigDecimal getWeight() {
+        return weight;
+    }
+
+    public void setWeight(BigDecimal weight) {
+        this.weight = weight;
+    }
+
+    public Integer getEquipmentId() {
+        return equipmentId;
+    }
+
+    public void setEquipmentId(Integer equipmentId) {
+        this.equipmentId = equipmentId;
+    }
+}

src/main/java/com/wms/entity/app/wcs/WmsReceiveTaskResultEntity.java

@@ -0,0 +1,74 @@
+package com.wms.entity.app.wcs;
+
+import com.wms.entity.BaseEntity;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * WCS向WMS发送任务结果请求实体类
+ */
+public class WmsReceiveTaskResultEntity extends BaseEntity {
+
+    /**
+     * WMS任务编号
+     */
+    @NotBlank(message = "任务ID不允许为空")
+    private String taskId;
+    /**
+     * 任务状态
+     */
+    @NotNull(message = "任务状态不允许为空")
+    private Integer taskStatus;
+    /**
+     * 任务终点
+     */
+    private String destination;
+    /**
+     * 载具号/箱号
+     */
+    private String vehicleNo;
+    /**
+     * 任务信息
+     */
+    private String message;
+
+    public String getTaskId() {
+        return taskId;
+    }
+
+    public void setTaskId(String taskId) {
+        this.taskId = taskId;
+    }
+
+    public Integer getTaskStatus() {
+        return taskStatus;
+    }
+
+    public void setTaskStatus(Integer taskStatus) {
+        this.taskStatus = taskStatus;
+    }
+
+    public String getDestination() {
+        return destination;
+    }
+
+    public void setDestination(String destination) {
+        this.destination = destination;
+    }
+
+    public String getVehicleNo() {
+        return vehicleNo;
+    }
+
+    public void setVehicleNo(String vehicleNo) {
+        this.vehicleNo = vehicleNo;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+}

src/main/java/com/wms/entity/common/WmsApiResponse.java

@@ -0,0 +1,30 @@
+package com.wms.entity.common;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class WmsApiResponse<T> {
+
+    /**
+     * 返回代码
+     */
+    @JsonProperty(value = "code")
+    private Integer code;
+
+    /**
+     * 返回消息
+     */
+    @JsonProperty(value = "message")
+    private String message;
+
+    /**
+     * 返回信息
+     */
+    @JsonProperty(value = "returnData")
+    private T returnData;
+
+
+}

src/main/java/com/wms/entity/common/WmsApiResponseByCheckBack.java

@@ -0,0 +1,47 @@
+package com.wms.entity.common;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+@Data
+@AllArgsConstructor
+public class WmsApiResponseByCheckBack<T> {
+
+    /**
+     * 返回代码
+     */
+    @JsonProperty(value = "code")
+    private Integer code;
+
+    /**
+     * 返回消息
+     */
+    @JsonProperty(value = "message")
+    private String message;
+
+    /**
+     * 返回消息
+     */
+    @JsonProperty(value = "goodsId")
+    private String goodsId;
+
+    /**
+     * 返回消息
+     */
+    @JsonProperty(value = "goodsNum")
+    private BigDecimal goodsNum;
+
+
+    @JsonProperty(value = "rowId")
+    private String rowId;
+    /**
+     * 返回信息
+     */
+    @JsonProperty(value = "returnData")
+    private T returnData;
+
+
+}

src/main/java/com/wms/entity/dto/PageQuery.java

@@ -0,0 +1,67 @@
+package com.wms.entity.dto;
+
+//import com.baomidou.mybatisplus.core.metadata.OrderItem;
+//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.wms.utils.StringUtils;
+import lombok.Data;
+
+/**
+ * 分页查询
+ */
+@Data
+public class PageQuery {
+    /**
+     * 页码
+     */
+    @JsonProperty("pageNo")
+    private Long pageNo = 1L;
+    /**
+     * 每页行数
+     */
+    @JsonProperty("pageSize")
+    private Long pageSize = 10L;
+    /**
+     * 排序字段
+     */
+    @JsonProperty("sortBy")
+    private String sortBy;
+    /**
+     * 是否升序
+     */
+    @JsonProperty("isAsc")
+    private Boolean isAsc = true;
+    /**
+     * 请求用户名
+     */
+    @JsonProperty("userName")
+    private String userName;
+
+//    /**
+//     * 将前端查询转换为数据库查询可用的分页查询
+//     * @param orderItems 排序字段
+//     * @return 分页查询
+//     * @param <PO> 实体类PO
+//     */
+//    public <PO> Page<PO> toMpPage(OrderItem ... orderItems){
+//        Page<PO> page = Page.of(pageNo, pageSize);
+//        if (StringUtils.isNotEmpty(sortBy)) {
+//            page.addOrder(new OrderItem().setColumn(sortBy).setAsc(isAsc));
+//        } else {
+//            page.addOrder(orderItems);
+//        }
+//        return page;
+//    }
+//
+//    /**
+//     * 传入 默认排序字段的转换
+//     * @param defaultSortValue 默认查询
+//     * @param isAsc 排序方式
+//     * @return 分页查询
+//     * @param <PO> 实体类
+//     */
+//    public <PO> Page<PO> toMpPage(String defaultSortValue, Boolean isAsc){
+//        return toMpPage(new OrderItem().setColumn(defaultSortValue).setAsc(isAsc));
+//    }
+}
+

src/main/java/com/wms/entity/dto/goodsRequest.java

@@ -0,0 +1,20 @@
+package com.wms.entity.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class goodsRequest {
+
+    /**
+     * 零件号
+     */
+    @JsonProperty(value = "goodsId")
+    private String goodsId;
+
+    /**
+     * 机型
+     */
+    @JsonProperty(value = "efSelect")
+    private String efSelect;
+}

src/main/java/com/wms/entity/dto/orderCheck/addOrderCheckRequest.java

@@ -0,0 +1,21 @@
+package com.wms.entity.dto.orderCheck;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class addOrderCheckRequest {
+    /**
+     * 盘点类型
+     */
+    @JsonProperty(value = "efSelect")
+    private String efSelect;
+
+    /**
+     * 对应信息
+     */
+    @JsonProperty(value = "goodsId")
+    public String goodsId;
+}

src/main/java/com/wms/entity/dto/orderCheck/queryOrderCheckRequest.java

@@ -0,0 +1,21 @@
+package com.wms.entity.dto.orderCheck;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class queryOrderCheckRequest {
+    /**
+     * 查询参数
+     */
+    @JsonProperty(value = "searchStr")
+    private String searchStr;
+
+    /**
+     * 状态
+     */
+    @JsonProperty(value = "orderStatus")
+    public List<Integer> orderStatus;
+}

src/main/java/com/wms/entity/dto/orderCheck/remarkOrderCheckRequest.java

@@ -0,0 +1,12 @@
+package com.wms.entity.dto.orderCheck;
+
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class remarkOrderCheckRequest {
+
+    @JsonProperty(value = "remarkReturn")
+    private String remarkReturn;
+}

src/main/java/com/wms/entity/dto/orderIn/bindingVehicleRequest.java

@@ -0,0 +1,21 @@
+package com.wms.entity.dto.orderIn;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class bindingVehicleRequest {
+
+    /**
+     * 载具号
+     */
+    @JsonProperty(value = "vehicleNo")
+    private String vehicleNo;
+
+    /**
+     * 条码
+     */
+    @JsonProperty(value = "code")
+    private String code;
+
+}

src/main/java/com/wms/entity/dto/orderIn/downOrderInRequest.java

@@ -0,0 +1,33 @@
+package com.wms.entity.dto.orderIn;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+@Data
+public class downOrderInRequest {
+
+    /**
+     * 物料号
+     * 发动机和原材料需要区分
+     */
+    @JsonProperty(value = "goodsId")
+    public String goodsId;
+
+    /**
+     * 数量
+     */
+    @JsonProperty(value = "goodsNum")
+    public int goodsNum;
+
+
+    /**
+     * 载具号
+     */
+    @JsonProperty(value = "vehicleNo")
+    public String vehicleNo;
+
+    /**
+     *
+     */
+    @JsonProperty(value = "userName")
+    public String userName;
+}

src/main/java/com/wms/entity/dto/orderIn/goodsInByTaskRequest.java

@@ -0,0 +1,16 @@
+package com.wms.entity.dto.orderIn;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class goodsInByTaskRequest {
+
+
+    @JsonProperty(value = "vehicleNo")
+    private String vehicleNo;
+
+    @JsonProperty(value = "selectByIn")
+    private String selectByIn;
+
+}

src/main/java/com/wms/entity/dto/orderIn/loginInBad.java

@@ -0,0 +1,25 @@
+package com.wms.entity.dto.orderIn;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import java.math.BigDecimal;
+@Data
+public class loginInBad {
+
+    @JsonProperty(value = "efSelect")
+    private String efSelect;
+
+    @JsonProperty(value = "vehicleNo")
+    private String vehicleNo;
+
+    @JsonProperty(value = "goodsId")
+    private String goodsId;
+
+    @JsonProperty(value = "goodsNum")
+    private BigDecimal goodsNum;
+
+    @JsonProperty(value = "model")
+    private String model;
+
+}