yangxueqian/wms_server_bojinsi_wuxi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2025/3/15珀金斯wms后端

Browse Source
This commit is contained in:
杨学谦 2025-03-16 00:14:48 +08:00
commit fb2f916b49
232 changed files with 28662 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
.gitignore vendored Normal file
View File

@ -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

316
mvnw vendored Normal file
View File

@ -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 "$@"

188
mvnw.cmd vendored Normal file
View File

@ -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%

190
pom.xml Normal file
View File

@ -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>

5008
sql/dbo.sql Normal file
View File

File diff suppressed because it is too large Load Diff

3
src/main/java/META-INF/MANIFEST.MF Normal file
View File

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

BIN
src/main/java/com/wms/.DS_Store vendored Normal file
View File

Binary file not shown.

24
src/main/java/com/wms/WmsApplication.java Normal file
View File

@ -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);
}
}

544
src/main/java/com/wms/bussiness/JobComponent.java Normal file
View File

@ -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();
}
}

791
src/main/java/com/wms/bussiness/TaskOperation.java Normal file
View File

@ -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
}

24
src/main/java/com/wms/bussiness/TaskTimer.java Normal file
View File

@ -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 {
}

57
src/main/java/com/wms/config/InitLocalConfig.java Normal file
View File

@ -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("加载配置到内存中...");
// }
// }
// }
}

23
src/main/java/com/wms/config/PageHelperConfig.java Normal file
View File

@ -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;
}
}

68
src/main/java/com/wms/constants/WmsConstants.java Normal file
View File

@ -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 梁州
* &#064;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();
}

30
src/main/java/com/wms/constants/enums/ConfigMapKeyEnum.java Normal file
View File

@ -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;
}
}

29
src/main/java/com/wms/constants/enums/GoodsStatus.java Normal file
View File

@ -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;
}
}

25
src/main/java/com/wms/constants/enums/KateTaskStatus.java Normal file
View File

@ -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;
}
}

27
src/main/java/com/wms/constants/enums/LocationStatus.java Normal file
View File

@ -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;
}
}

28
src/main/java/com/wms/constants/enums/OrderCheckStatusEnum.java Normal file
View File

@ -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;
}
}

26
src/main/java/com/wms/constants/enums/OrderInStatusEnum.java Normal file
View File

@ -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;
}
}

27
src/main/java/com/wms/constants/enums/OrderOutStatusEnum.java Normal file
View File

@ -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;
}
}

27
src/main/java/com/wms/constants/enums/ResponseCode.java Normal file
View File

@ -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;
}
}

34
src/main/java/com/wms/constants/enums/StockStatus.java Normal file
View File

@ -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;
}
}

37
src/main/java/com/wms/constants/enums/TaskType.java Normal file
View File

@ -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;
}
}

32
src/main/java/com/wms/constants/enums/UrlEnums.java Normal file
View File

@ -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;
}
}

27
src/main/java/com/wms/constants/enums/VehicleStatus.java Normal file
View File

@ -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;
}
}

31
src/main/java/com/wms/constants/enums/WcsTaskStatus.java Normal file
View File

@ -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;
}
}

35
src/main/java/com/wms/constants/enums/WmsTaskStatus.java Normal file
View File

@ -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;
}
}

8
src/main/java/com/wms/controller/BaseController.java Normal file
View File

@ -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());
}

87
src/main/java/com/wms/controller/ConfigController.java Normal file
View File

@ -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 梁州
* &#064;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);
}
}

133
src/main/java/com/wms/controller/DisplayController.java Normal file
View File

@ -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;
}
}

198
src/main/java/com/wms/controller/ExcelController.java Normal file
View File

@ -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);
}
}
}

373
src/main/java/com/wms/controller/GoodsController.java Normal file
View File

@ -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 梁州
* &#064;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);
}
}

336
src/main/java/com/wms/controller/LocationController.java Normal file
View File

@ -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 梁州
* &#064;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);
}
}

62
src/main/java/com/wms/controller/OrderCheckController.java Normal file
View File

@ -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);
}
}

210
src/main/java/com/wms/controller/OrderInController.java Normal file
View File

@ -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, "该母托号已下发任务，请勿重复下发");
}
}

174
src/main/java/com/wms/controller/OrderOutController.java Normal file
View File

@ -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);
}
}

91
src/main/java/com/wms/controller/RecordController.java Normal file
View File

@ -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);
}
}

133
src/main/java/com/wms/controller/StandController.java Normal file
View File

@ -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);
}
}

285
src/main/java/com/wms/controller/StockController.java Normal file
View File

@ -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 梁州
* &#064;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);
}
}

1354
src/main/java/com/wms/controller/TaskController.java Normal file
View File

File diff suppressed because it is too large Load Diff

339
src/main/java/com/wms/controller/TaskDealController.java Normal file
View File

@ -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);
}
}
}

255
src/main/java/com/wms/controller/TestController.java Normal file
View File

@ -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);
}
}

794
src/main/java/com/wms/controller/UserController.java Normal file
View File

@ -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 梁州
* &#064;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);
}
}
}

71
src/main/java/com/wms/controller/others/ContainerController.java Normal file
View File

@ -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", "接收到任务反馈失败，请稍后再试");
}
}
}

57
src/main/java/com/wms/controller/others/MesController.java Normal file
View File

@ -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);
}
}

831
src/main/java/com/wms/controller/others/WcsController.java Normal file
View File

@ -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, "接收到任务反馈失败，请稍后再试");
}
}
}

BIN
src/main/java/com/wms/entity/.DS_Store vendored Normal file
View File

Binary file not shown.

9
src/main/java/com/wms/entity/BaseEntity.java Normal file
View File

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

139
src/main/java/com/wms/entity/app/FinishPickTaskRequest.java Normal file
View File

@ -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;
}
}

31
src/main/java/com/wms/entity/app/FinishVehicleAndPartRequest.java Normal file
View File

@ -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;
}
}

57
src/main/java/com/wms/entity/app/InventoryTask.java Normal file
View File

@ -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;
}
}

36
src/main/java/com/wms/entity/app/LayerLocation.java Normal file
View File

@ -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;
}
}

70
src/main/java/com/wms/entity/app/MenuEntity.java Normal file
View File

@ -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;
}
}

62
src/main/java/com/wms/entity/app/ResponseEntity.java Normal file
View File

@ -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;
}
}

34
src/main/java/com/wms/entity/app/RowLocation.java Normal file
View File

@ -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;
}
}

166
src/main/java/com/wms/entity/app/TaskInRequestEntity.java Normal file
View File

@ -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;
}
}

57
src/main/java/com/wms/entity/app/TaskOutRequestEntity.java Normal file
View File

@ -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;
}
}

34
src/main/java/com/wms/entity/app/UserConfigEntity.java Normal file
View File

@ -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;
}
}

42
src/main/java/com/wms/entity/app/container/ContainerApiLocalResponse.java Normal file
View File

@ -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;
}

56
src/main/java/com/wms/entity/app/container/CreateInstoreTaskRequest.java Normal file
View File

@ -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;
}

57
src/main/java/com/wms/entity/app/container/CreateInstoreTaskResponse.java Normal file
View File

@ -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;
}

57
src/main/java/com/wms/entity/app/container/SendContainerTaskRequest.java Normal file
View File

@ -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;
}

39
src/main/java/com/wms/entity/app/container/TaskStateNoticeRequest.java Normal file
View File

@ -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;
}

55
src/main/java/com/wms/entity/app/display/LocationData.java Normal file
View File

@ -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;
}
}

45
src/main/java/com/wms/entity/app/display/LocationInfo.java Normal file
View File

@ -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;
}
}

35
src/main/java/com/wms/entity/app/mes/CheckNoticeRequest.java Normal file
View File

@ -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;
}

29
src/main/java/com/wms/entity/app/mes/MesApiLocalResponse.java Normal file
View File

@ -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;
}

68
src/main/java/com/wms/entity/app/mes/OutNoticeRequest.java Normal file
View File

@ -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;
}

47
src/main/java/com/wms/entity/app/mes/OutNoticeRequestRow.java Normal file
View File

@ -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;
}

71
src/main/java/com/wms/entity/app/mes/ReceiptInRequest.java Normal file
View File

@ -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;
}

26
src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRequest.java Normal file
View File

@ -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;
}

20
src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRow.java Normal file
View File

@ -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;
}

29
src/main/java/com/wms/entity/app/mes/SendMesGoodsMoveRequest.java Normal file
View File

@ -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;
}

43
src/main/java/com/wms/entity/app/mes/SendMesPutInGoodsRequest.java Normal file
View File

@ -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;
}

27
src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRequest.java Normal file
View File

@ -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;
}

31
src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRow.java Normal file
View File

@ -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;
}

32
src/main/java/com/wms/entity/app/mes/SendMesStockRequest.java Normal file
View File

@ -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;
}

23
src/main/java/com/wms/entity/app/vo/FileVo.java Normal file
View File

@ -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;
}

31
src/main/java/com/wms/entity/app/vo/RoleOption.java Normal file
View File

@ -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;
}
}

40
src/main/java/com/wms/entity/app/wcs/DisposeStandRequest.java Normal file
View File

@ -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;
}
}

45
src/main/java/com/wms/entity/app/wcs/PickTaskRequest.java Normal file
View File

@ -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;
}
}

40
src/main/java/com/wms/entity/app/wcs/PickTaskResponse.java Normal file
View File

@ -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;
}
}

34
src/main/java/com/wms/entity/app/wcs/RequireInRequest.java Normal file
View File

@ -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;
}

13
src/main/java/com/wms/entity/app/wcs/RequireOutRequest.java Normal file
View File

@ -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;
}

83
src/main/java/com/wms/entity/app/wcs/WcsGoods.java Normal file
View File

@ -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;
}
}

152
src/main/java/com/wms/entity/app/wcs/WcsTask.java Normal file
View File

@ -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;
}
}

102
src/main/java/com/wms/entity/app/wcs/WcsToWmsInspectVesselEntity.java Normal file
View File

@ -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;
}
}

74
src/main/java/com/wms/entity/app/wcs/WmsReceiveTaskResultEntity.java Normal file
View File

@ -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;
}
}

30
src/main/java/com/wms/entity/common/WmsApiResponse.java Normal file
View File

@ -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;
}

47
src/main/java/com/wms/entity/common/WmsApiResponseByCheckBack.java Normal file
View File

@ -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;
}

67
src/main/java/com/wms/entity/dto/PageQuery.java Normal file
View File

@ -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));
// }
}

20
src/main/java/com/wms/entity/dto/goodsRequest.java Normal file
View File

@ -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;
}

21
src/main/java/com/wms/entity/dto/orderCheck/addOrderCheckRequest.java Normal file
View File

@ -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;
}

21
src/main/java/com/wms/entity/dto/orderCheck/queryOrderCheckRequest.java Normal file
View File

@ -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;
}

12
src/main/java/com/wms/entity/dto/orderCheck/remarkOrderCheckRequest.java Normal file
View File

@ -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;
}

21
src/main/java/com/wms/entity/dto/orderIn/bindingVehicleRequest.java Normal file
View File

@ -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;
}

33
src/main/java/com/wms/entity/dto/orderIn/downOrderInRequest.java Normal file
View File

@ -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;
}

16
src/main/java/com/wms/entity/dto/orderIn/goodsInByTaskRequest.java Normal file
View File

@ -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;
}

25
src/main/java/com/wms/entity/dto/orderIn/loginInBad.java Normal file
View File

@ -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;
}

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