Compare commits

...

45 Commits

Author SHA1 Message Date
fdzcxy212206413 77a83d6869 Merge pull request '所有项目代码' (#1) from grs into main
10 months ago
yjxx 70959b00f0 所有项目完成!
10 months ago
yjxx 157de6830e 所有项目完成!
10 months ago
yjxx 4ae25f1c6b 所有项目完成!
11 months ago
yjxx 6b54e769fd 所有项目完成!
11 months ago
yjxx 8f3c97fa52 小修改
11 months ago
yjxx 83e365d75d 终于尼玛调试完了用户,就差代取和快递员了!!!!
11 months ago
yjxx 0abbaab6f8 小修改
11 months ago
yjxx 7101d6b7d2 封装快递记录查询
11 months ago
yjxx e8d409bd38 修改用户查看别人发给自己的消息
11 months ago
yjxx 754d59c9b4 小修改
11 months ago
yjxx 42b288d23c 寄件和收件不能是同一个地方
11 months ago
yjxx ce7718f68c 寄件和收件不能是同一个地方
11 months ago
yjxx cf59446afc 添加了重量自定义注解
11 months ago
yjxx 9ef8ec7a6b 真对寄件进行修改
11 months ago
yjxx 8a149c54b6 小修改
11 months ago
yjxx d3382cda09 用户功能的用户查询快递
11 months ago
yjxx 3b1fb1aa13 管理员功能全部实现
11 months ago
yjxx 7dd2f481ac 管理员获取正在留言的人的所有聊天记录
11 months ago
yjxx c97c4a15db 小修改
11 months ago
yjxx 59db863195 小修改
11 months ago
yjxx 90cfec7d93 管理员获取所有快递信息
11 months ago
yjxx 31ba23d47f 小修改
11 months ago
yjxx 53aa97a461 小修改
11 months ago
yjxx 8e1250df12 小修改
11 months ago
yjxx de12494bbd 小修改
11 months ago
yjxx ba7d5d8709 小修改
11 months ago
yjxx b320b3e34c 小修改
11 months ago
yjxx 2e3d44d4f9 阶段四:快递员功能
11 months ago
yjxx c1766f3259 阶段四:快递员功能
11 months ago
yjxx 9c33185231 管理员和用户功能成功通过Postman测试验收
11 months ago
yjxx 93febaf68e 小修改
11 months ago
yjxx 7a12313da6 项目三阶段:用户功能(未测试版本)
11 months ago
yjxx 1b19f8ee70 项目三阶段:用户功能(未测试版本)
11 months ago
yjxx 038760b094 项目一阶段和二阶段通过测试验收
12 months ago
yjxx 9e65e55290 小修改
12 months ago
yjxx 5eef15f557 小修改
12 months ago
yjxx 1b0cb41766 小修改
12 months ago
yjxx 71a93b0515 验收通用功能并进行修改
12 months ago
yjxx 0bfdba7e35 验收通用功能并进行修改
12 months ago
yjxx bdaec402ed 项目阶段二:管理员功能
12 months ago
yjxx c202b4f240 项目一阶段: 细节修改
12 months ago
yjxx 180019adae 项目一阶段功能增加:用户禁用功能
12 months ago
yjxx a65b2c1f2b Merge branch 'grs' of https://bdgit.educoder.net/fdzcxy212206413/jty into grs
12 months ago
yjxx bc581dbe4f 项目一阶段:完成用户 管理员 快递员的通用功能
12 months ago

2
.gitattributes vendored

@ -0,0 +1,2 @@
/mvnw text eol=lf
*.cmd text eol=crlf

33
.gitignore vendored

@ -0,0 +1,33 @@
HELP.md
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/

@ -0,0 +1,20 @@
# 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
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
wrapperVersion=3.3.2
distributionType=only-script
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip
distributionSha256Sum=4ec3f26fb1a692473aea0235c300bd20f0f9fe741947c82c1234cefd76ac3a3c

259
mvnw vendored

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

149
mvnw.cmd vendored

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

@ -0,0 +1,128 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.3.4</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>jty</groupId>
<artifactId>ExpressDistributionSystem</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>ExpressDistributionSystem</name>
<description>ExpressDistributionSystem</description>
<url/>
<licenses>
<license/>
</licenses>
<developers>
<developer/>
</developers>
<scm>
<connection/>
<developerConnection/>
<tag/>
<url/>
</scm>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- MySQL JDBC 驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 参数校验依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<!-- Mybatis Plus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-spring-boot3-starter</artifactId>
<version>3.5.5</version>
</dependency>
<!-- 工具类: 字符串处理、数字处理、对象操作等 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
<!-- 支持将 Java 对象转换为 JSON 格式,以及将 JSON 字符串解析为 Java 对象 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.0</version>
</dependency>
<!-- JWT令牌 -->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>4.4.0</version>
</dependency>
<!-- 注解 -->
<dependency>
<groupId>org.jetbrains</groupId>
<artifactId>annotations</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>

@ -0,0 +1,14 @@
package jty.expressdistributionsystem.DTO;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
@Data
public class AddresseeDTO {
@NotNull
private Long goodsId;
@NotBlank(message = "取件码不能为空")
private String claimCode;
}

@ -0,0 +1,19 @@
package jty.expressdistributionsystem.DTO;
import jty.expressdistributionsystem.entity.Address;
import jty.expressdistributionsystem.entity.Goods;
import jty.expressdistributionsystem.entity.Records;
import jty.expressdistributionsystem.entity.User;
import lombok.Data;
@Data
public class EmExpressDTO {
private User sendUser;
private User getUser;
private User addressee;
private User express;
private Address addressTo;
private Goods goods;
private Address addressFrom;
private Records records;
}

@ -0,0 +1,30 @@
package jty.expressdistributionsystem.DTO;
import jty.expressdistributionsystem.entity.Address;
import jty.expressdistributionsystem.entity.Goods;
import jty.expressdistributionsystem.entity.Records;
import jty.expressdistributionsystem.entity.User;
import lombok.Data;
@Data
public class ExpressListDTO {
private Records records;
private Goods goods;
private User sender; // 寄件人
private User recipient; // 收件人
private User addressee; // 签收者
private User courier; // 派送的快递员
private Address addressFrom; // 从哪里送的
private Address addressTo; // 送到哪里
public ExpressListDTO(Records records, Goods goods, User sender, User recipient, User addressee, User courier, Address addressFrom, Address addressTo) {
this.records = records;
this.goods = goods;
this.sender = sender;
this.recipient = recipient;
this.addressee = addressee;
this.courier = courier;
this.addressFrom = addressFrom;
this.addressTo = addressTo;
}
}

@ -0,0 +1,33 @@
package jty.expressdistributionsystem.DTO;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jty.expressdistributionsystem.validation.inter.ValidQuality;
import lombok.Data;
@Data
public class GoodsDTO {
@NotBlank(message = "请选择快递公司")
private String company;
@NotBlank(message = "收件人名字不能为空")
private String getUserName;
@NotBlank(message = "快递名称不能为空")
private String name;
/**
* 使 @NotBlank
* NotBlank
*/
@ValidQuality
private Double quality;
@NotBlank(message = "发货地不能为空")
private String addressFrom;
@NotBlank(message = "收件地址不能为空")
private String addressTo;
}

@ -0,0 +1,16 @@
package jty.expressdistributionsystem.DTO;
import lombok.Data;
@Data
public class GoodsEmDTO {
private String name;
private String sendUser;
private String getUser;
private String employee;
private Double quality;
private String addressFrom;
private String addressTo;
private Integer mark;
private String addressee;
}

@ -0,0 +1,16 @@
package jty.expressdistributionsystem.DTO;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class PickUpExpressDTO {
@NotBlank(message = "收件人名字不能为空")
private String master;
@NotBlank(message = "快递码不能为空")
private String expressCode;
@NotBlank(message = "取件码不能为空")
private String claimCode;
}

@ -0,0 +1,17 @@
package jty.expressdistributionsystem.DTO;
import jty.expressdistributionsystem.entity.*;
import lombok.Data;
@Data
public class RecordsListDTO {
private Goods goods; // 查看货物名称
private Address addressFrom; // 查看发货地
private Address addressTo; // 查看发到哪里
private User employee; // 查看快递员
private User addressee; // 查看谁签收的
private User sendUser; // 查看谁发的
private User getUserId; // 查看发给谁的
private Code code; // 快递取件码
private Records record; // 查看是否被签收
}

@ -0,0 +1,13 @@
package jty.expressdistributionsystem.DTO;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class SendMessageDTO {
@NotBlank(message = "请选择你的聊天对象")
private String toUserName;
@NotBlank(message = "消息不能为空")
private String content;
}

@ -0,0 +1,20 @@
package jty.expressdistributionsystem.DTO;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
@Data
public class UserLoginByAccountDTO {
@NotBlank(message = "账号不能为空")
@Pattern(regexp = "^(?!\\s)([A-Za-z0-9]{1,10})$", message = "账号长度在1-10位之间")
private String account;
@NotBlank(message = "密码不能为空")
@Pattern(regexp = "^.+$", message = "密码不能为空")
private String password;
@NotNull
private Integer mark;
}

@ -0,0 +1,15 @@
package jty.expressdistributionsystem.DTO;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
@Data
public class UserModifyInfoDTO {
@NotBlank(message = "用户名不能为空")
private String userName;
@NotBlank(message = "手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号不存在")
private String phone;
}

@ -0,0 +1,25 @@
package jty.expressdistributionsystem.DTO;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
@Data
public class UserModifyPasswordDTO {
@NotBlank(message = "旧密码不能为空")
@Pattern(regexp = "^.+$", message = "旧密码不能为空")
private String oldPassword;
@NotBlank(message = "新密码不能为空")
@Pattern(regexp = "^.+$", message = "新密码不能为空")
private String newPassword;
@NotBlank(message = "再次输入的密码不能为空")
@Pattern(regexp = "^.+$", message = "再次输入的密码不能为空")
private String reNewPassword;
@NotBlank(message = "身份证不能为空")
@Pattern(regexp = "^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\\d{3}(\\d|X|x)$",
message = "身份证格式不正确")
private String identity;
}

@ -0,0 +1,20 @@
package jty.expressdistributionsystem;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@SpringBootApplication
@MapperScan("jty.expressdistributionsystem.mapper")
@EnableTransactionManagement
@Slf4j
public class ExpressDistributionSystemApplication {
public static void main(String[] args) {
SpringApplication.run(ExpressDistributionSystemApplication.class, args);
log.info("猫咪物流启动成功");
}
}

@ -0,0 +1,19 @@
package jty.expressdistributionsystem.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class CrossOriginConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOriginPatterns("*")
.allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "PATCH")
//允许所有的请求方法访问该跨域资源服务器
.allowCredentials(true)
.maxAge(3600)
.allowedHeaders("Authorization", "Content-Type", "Accept", "Origin", "X-Requested-With");
}
}

@ -0,0 +1,22 @@
package jty.expressdistributionsystem.config;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
this.strictInsertFill(metaObject, "createTime", LocalDateTime::now, LocalDateTime.class);
this.strictInsertFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
}
@Override
public void updateFill(MetaObject metaObject) {
this.strictUpdateFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
}
}

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

@ -0,0 +1,18 @@
package jty.expressdistributionsystem.config;
import jakarta.annotation.Resource;
import jty.expressdistributionsystem.interceptors.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Resource
private LoginInterceptor loginInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(loginInterceptor).excludePathPatterns("/common/register", "/common/loginByAccount");
}
}

@ -0,0 +1,131 @@
package jty.expressdistributionsystem.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jakarta.annotation.Resource;
import jty.expressdistributionsystem.DTO.ExpressListDTO;
import jty.expressdistributionsystem.DTO.SendMessageDTO;
import jty.expressdistributionsystem.entity.*;
import jty.expressdistributionsystem.service.*;
import jty.expressdistributionsystem.utils.GetIdUtil;
import jty.expressdistributionsystem.utils.SendMessageUtil;
import jty.expressdistributionsystem.utils.ThreadLocalUtil;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@RestController
@RequestMapping("/admin")
@Slf4j
public class AdminController {
@Resource
private UserService userService;
@Resource
private MessageService messageService;
@Resource
private RecordsService recordsService;
@Resource
private GoodsService goodsService;
@Resource
private AddressService addressService;
// 管理员查看用户或者快递员信息(finish)
@GetMapping("/infoList")
public Result<Page<User>> getUserList(@RequestParam int page, @RequestParam int pageSize, @RequestParam int mark) {
if (page <= 0 || pageSize <= 0) {
return new Result<>(400, "页码和每页大小必须大于0", null);
}
// 分页
Page<User> pageInfo = new Page<>(page, pageSize);
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 添加查询条件
queryWrapper.eq(User::getMark, mark);
// 排序
queryWrapper.orderByDesc(User::getLoginTime)
.orderByDesc(User::getCreateTime);
userService.page(pageInfo, queryWrapper);
return new Result<>(200, "", pageInfo);
}
// 拉黑删除快递员或者用户(finish)
@DeleteMapping("/delete/{id}")
public Result<String> delete(@PathVariable Long id, @RequestParam @NotNull String operation) {
User user = userService.getById(id);
if (user == null) {
return new Result<>(401, "账号不存在", "");
}
switch (operation) {
// 禁用
case "0" -> user.setDisabled(1);
// 解除禁用
case "1" -> user.setDisabled(0);
// 直接删除
case "2" -> {
userService.removeById(user.getId());
return new Result<>(200, "删除成功", "");
}
}
userService.updateById(user);
return new Result<>(200, "操作成功", "");
}
// 管理员发送消息(finish)
@PostMapping("/sendMessage")
public Result<String> sendMessage(@RequestBody @Validated SendMessageDTO sendMessageDTO) {
Message message = SendMessageUtil.sendMessage(sendMessageDTO, userService);
messageService.save(message);
return new Result<>(200, "发送成功", "");
}
// 获取正在留言的人的所有聊天记录(finish)
@GetMapping("/allMessage")
public Result<List<List<Message>>> getAllMessage(@RequestParam Long toId) {
Long meId = GetIdUtil.getId();
LambdaQueryWrapper<Message> messageLambdaQueryWrapper = new LambdaQueryWrapper<>();
List<List<Message>> list = new ArrayList<>();
// 先获取自己发给那个人的
messageLambdaQueryWrapper.eq(Message::getSendUserId, meId)
.eq(Message::getGetUserId, toId);
list.add(messageService.list(messageLambdaQueryWrapper));
// 再获取别人发给自己的
messageLambdaQueryWrapper.clear();
messageLambdaQueryWrapper.eq(Message::getGetUserId, meId)
.eq(Message::getSendUserId, toId);
list.add(messageService.list(messageLambdaQueryWrapper));
return new Result<>(200, "", list);
}
// 管理员获取所有快递信息(finish)
@GetMapping("/express")
public Result<Page<ExpressListDTO>> getAllExpress(@RequestParam int page, @RequestParam int pageSize) {
Page<Records> recordsPage = new Page<>(page, pageSize);
recordsService.page(recordsPage);
List<ExpressListDTO> expressListDTOList = new ArrayList<>();
// 获取所有的快递记录
List<Records> recordsList = recordsService.list();
for (Records records : recordsList) {
Goods goods = goodsService.getById(records.getGoodsId());
// 查询寄件人、收件人、签收者、快递员信息
User sender = userService.getById(records.getSendUserId());
User recipient = userService.getById(records.getGetUserId());
User addressee = userService.getById(records.getAddresseeId());
User courier = userService.getById(records.getExpressId());
// 查询地址信息: 从哪里送的 送到哪里
Address addressTo = addressService.getById(records.getAddressId());
Address addressFrom = addressService.getById(records.getAddressFrom());
ExpressListDTO expressListDTO = new ExpressListDTO(records, goods, sender, recipient, addressee, courier, addressFrom, addressTo);
expressListDTOList.add(expressListDTO);
}
Page<ExpressListDTO> expressDTOPage = new Page<>(recordsPage.getCurrent(), recordsPage.getSize(), recordsPage.getTotal());
expressDTOPage.setRecords(expressListDTOList);
return new Result<>(200, "", expressDTOPage);
}
}

@ -0,0 +1,160 @@
package jty.expressdistributionsystem.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import jakarta.annotation.Resource;
import jty.expressdistributionsystem.DTO.UserLoginByAccountDTO;
import jty.expressdistributionsystem.DTO.UserModifyInfoDTO;
import jty.expressdistributionsystem.DTO.UserModifyPasswordDTO;
import jty.expressdistributionsystem.entity.Result;
import jty.expressdistributionsystem.entity.User;
import jty.expressdistributionsystem.service.UserService;
import jty.expressdistributionsystem.utils.GetIdUtil;
import jty.expressdistributionsystem.utils.JwtUtil;
import jty.expressdistributionsystem.utils.Md5Util;
import jty.expressdistributionsystem.utils.ThreadLocalUtil;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@RestController
@RequestMapping("/common")
@Slf4j
public class CommonController {
@Resource
private UserService userService;
@Resource
private StringRedisTemplate stringRedisTemplate;
// 注册(finish)
@PostMapping("/register")
public Result<String> register(@RequestBody @Validated @NotNull User user) {
// 查找用户是否存在
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("user_name", user.getUserName())
.or()
.eq("account", user.getAccount())
.or()
.eq("phone", user.getPhone());
User u = userService.getOne(queryWrapper);
if (u != null) {
return new Result<>(409, "账号或用户名或手机号已存在", "");
}
// 密码加密
user.setPassword(Md5Util.getMD5String(user.getPassword()));
// 用户数据入库
userService.save(user);
return new Result<>(200, "注册成功", "");
}
// 通过账号登录(finish)
@PostMapping("/loginByAccount")
public Result<String> login(@RequestBody @Validated @NotNull UserLoginByAccountDTO userLoginByAccountDTO) {
// 删除ThreadLocal存储信息
ThreadLocalUtil.remove();
// 查询用户是否存在
Optional<User> optionalUser = Optional.ofNullable(userService.getOne(new QueryWrapper<User>()
.eq("account", userLoginByAccountDTO.getAccount())));
if (optionalUser.isEmpty() || !Md5Util.getMD5String(userLoginByAccountDTO.getPassword()).equals(optionalUser.get().getPassword())) {
return new Result<>(401, "账号或者密码错误", "");
}
User user = optionalUser.get();
if (!Objects.equals(userLoginByAccountDTO.getMark(), user.getMark())) {
return new Result<>(401, "请选择正确身份", "");
}
if (user.getDisabled() == 1) {
return new Result<>(403, "该账号已被禁用, 请联系管理员", "");
}
user.setLoginTime(LocalDateTime.now());
userService.update(user, new UpdateWrapper<User>().eq("id", user.getId()));
// 校验通过
Map<String, Object> claims = new HashMap<>();
claims.put("id", user.getId());
ThreadLocalUtil.set(user.getId());
claims.put("account", userLoginByAccountDTO.getAccount());
// 获取token
String token = JwtUtil.genToken(claims);
// 存放token到redis当中进行持久化存储
ValueOperations<String, String> stringStringValueOperations = stringRedisTemplate.opsForValue();
// 设置过期时间(1天)
stringStringValueOperations.set(token, token, 1, TimeUnit.DAYS);
// 返回token给前端
return new Result<>(200, "登录成功", token);
}
// 修改个人信息
@PutMapping("/modify")
public Result<Object> modifyInfo(@RequestBody @Validated @NotNull UserModifyInfoDTO userModifyInfoDTO) {
// 获取登录用户id
Long id = GetIdUtil.getId();
User user = userService.getById(id);
// 检查phone和userName是否与当前用户信息一致
boolean isPhoneSame = user.getPhone().equals(userModifyInfoDTO.getPhone());
boolean isUserNameSame = user.getUserName().equals(userModifyInfoDTO.getUserName());
if (isPhoneSame && isUserNameSame) {
return new Result<>(400, "请修改您的信息", "");
}
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
if (!isPhoneSame) {
queryWrapper.eq("phone", userModifyInfoDTO.getPhone());
if (userService.getOne(queryWrapper) != null) {
return new Result<>(400, "该手机号已被注册", "");
}
user.setPhone(userModifyInfoDTO.getPhone());
}
queryWrapper.clear();
if (!isUserNameSame) {
queryWrapper.eq("user_name", userModifyInfoDTO.getUserName());
if (userService.getOne(queryWrapper) != null) {
return new Result<>(400, "该用户名已被使用", "");
}
user.setUserName(userModifyInfoDTO.getUserName());
}
user.setUpdateTime(null);
userService.updateById(user);
return new Result<>(200, "用户信息修改成功", user);
}
// 修改个人密码
@PutMapping("/rePassword")
public Result<String> modifyPassword(
@RequestBody @Validated @NotNull UserModifyPasswordDTO userModifyPasswordDTO) {
// 判断密码
if (userModifyPasswordDTO.getOldPassword().equals(userModifyPasswordDTO.getNewPassword())) {
return new Result<>(409, "新密码不得和旧密码一致", "");
}
if (!userModifyPasswordDTO.getNewPassword().equals(userModifyPasswordDTO.getReNewPassword())) {
return new Result<>(409, "两次输入密码不相同", "");
}
Long id = GetIdUtil.getId();
User user = userService.getById(id);
if (!user.getIdentity().equals(userModifyPasswordDTO.getIdentity())) {
return new Result<>(409, "身份证有误", "");
}
user.setPassword(Md5Util.getMD5String(userModifyPasswordDTO.getNewPassword()));
user.setUpdateTime(null);
userService.updateById(user);
// 删除当前线程的存储信息
ThreadLocalUtil.remove();
return new Result<>(200, "密码修改成功, 请重新登陆", "");
}
// 获取个人信息(finish)
@GetMapping("/info")
public Result<User> getInfo() {
Long id = GetIdUtil.getId();
User user = userService.getById(id);
return new Result<>(200, "", user);
}
}

@ -0,0 +1,110 @@
package jty.expressdistributionsystem.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jakarta.annotation.Resource;
import jty.expressdistributionsystem.DTO.EmExpressDTO;
import jty.expressdistributionsystem.DTO.GoodsEmDTO;
import jty.expressdistributionsystem.entity.*;
import jty.expressdistributionsystem.service.AddressService;
import jty.expressdistributionsystem.service.GoodsService;
import jty.expressdistributionsystem.service.RecordsService;
import jty.expressdistributionsystem.service.UserService;
import jty.expressdistributionsystem.utils.GetIdUtil;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@RestController
@RequestMapping("/employee")
public class EmployeeController {
@Resource
private RecordsService recordsService;
@Resource
private GoodsService goodsService;
@Resource
private UserService userService;
@Resource
private AddressService addressService;
// 查询所有自己派送的快递(finish)
@GetMapping("/express")
public Result<Page<EmExpressDTO>> getAllExpress(@RequestParam int page, @RequestParam int pageSize) {
if (page <= 0 || pageSize <= 0) {
return new Result<>(400, "页码和每页大小必须大于0", null);
}
Long expressId = GetIdUtil.getId(); // 获取当前用户的 ID假设此方法返回当前用户的 expressId
// 根据 expressId 查询 Records 表中的快递记录
LambdaQueryWrapper<Records> recordsQueryWrapper = new LambdaQueryWrapper<>();
recordsQueryWrapper.eq(Records::getExpressId, expressId)
.orderByDesc(Records::getCreateTime); // 按时间降序排序
Page<Records> recordsPage = recordsService.page(new Page<>(page, pageSize), recordsQueryWrapper);
List<EmExpressDTO> emExpressDTOList = new ArrayList<>();
for (Records record : recordsPage.getRecords()) {
EmExpressDTO emExpressDTO = new EmExpressDTO();
// 查询相关用户(发送者、接收者)
User sendUser = userService.getById(record.getSendUserId());
User getUser = userService.getById(record.getGetUserId());
User addressee = userService.getById(record.getAddresseeId());
// 查询地址信息
Address addressFrom = addressService.getById(record.getAddressFrom());
Address addressTo = addressService.getById(record.getAddressId());
// 查询商品信息
Goods goods = goodsService.getById(record.getGoodsId());
emExpressDTO.setSendUser(sendUser);
emExpressDTO.setGetUser(getUser);
emExpressDTO.setAddressee(addressee);
emExpressDTO.setAddressFrom(addressFrom);
emExpressDTO.setAddressTo(addressTo);
emExpressDTO.setGoods(goods);
emExpressDTO.setRecords(record);
emExpressDTOList.add(emExpressDTO);
}
Page<EmExpressDTO> resultPage = new Page<>(page, pageSize);
resultPage.setRecords(emExpressDTOList);
resultPage.setTotal(recordsPage.getTotal());
return new Result<>(200, "查询成功", resultPage);
}
// 查询单件快递信息
@PostMapping("/expressInfo")
public Result<GoodsEmDTO> getExpressInfo(@RequestParam String expressCode) {
if (expressCode.isEmpty()) {
return new Result<>(404, "快递不存在", null);
}
LambdaQueryWrapper<Goods> goodsLambdaQueryWrapper = new LambdaQueryWrapper<>();
goodsLambdaQueryWrapper.eq(Goods::getExpressCode, expressCode);
Goods goods = goodsService.getOne(goodsLambdaQueryWrapper);
if (goods == null) {
return new Result<>(404, "快递不存在", null);
}
LambdaQueryWrapper<Records> recordsLambdaQueryWrapper = new LambdaQueryWrapper<>();
recordsLambdaQueryWrapper.eq(Records::getGoodsId, goods.getId());
Records records = recordsService.getOne(recordsLambdaQueryWrapper);
User sendUser = userService.getById(goods.getSendUserId());
User getUser = userService.getById(goods.getGetUserId());
User employee = userService.getById(records.getExpressId());
Address addressFrom = addressService.getById(records.getAddressFrom());
Address addressTo = addressService.getById(records.getAddressId());
User addressee = userService.getById(records.getAddresseeId());
// 填充DTO
GoodsEmDTO goodsEmDTO = new GoodsEmDTO();
goodsEmDTO.setName(goods.getName());
goodsEmDTO.setSendUser(sendUser.getUserName());
goodsEmDTO.setGetUser(getUser.getUserName());
goodsEmDTO.setQuality(goods.getQuality());
goodsEmDTO.setAddressFrom(addressFrom.getAddress());
goodsEmDTO.setAddressTo(addressTo.getAddress());
goodsEmDTO.setMark(records.getMark());
goodsEmDTO.setEmployee(employee.getUserName());
if (addressee != null) {
goodsEmDTO.setAddressee(addressee.getUserName());
}
return new Result<>(200, "查询成功", goodsEmDTO);
}
}

@ -0,0 +1,336 @@
package jty.expressdistributionsystem.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jakarta.annotation.Resource;
import jty.expressdistributionsystem.DTO.*;
import jty.expressdistributionsystem.entity.*;
import jty.expressdistributionsystem.service.*;
import jty.expressdistributionsystem.utils.ClaimCodeUtil;
import jty.expressdistributionsystem.utils.ExpressCodeUtil;
import jty.expressdistributionsystem.utils.GetIdUtil;
import jty.expressdistributionsystem.utils.SendMessageUtil;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@RestController
@RequestMapping("/user")
public class UserController {
@Resource
private UserService userService;
@Resource
private MessageService messageService;
@Resource
private RecordsService recordsService;
@Resource
private CodeService codeService;
@Resource
private GoodsService goodsService;
@Resource
private AddressService addressService;
// 用户发消息(finish)
@PostMapping("/sendMessage")
public Result<String> sendMessage(@Validated @RequestBody SendMessageDTO sendMessageDTO) {
Message message = SendMessageUtil.sendMessage(sendMessageDTO, userService);
messageService.save(message);
return new Result<>(200, "发送成功", "");
}
// 给快递员点赞(finish)
@PostMapping("/likes")
public Result<String> like(@RequestParam Long id) {
User employee = userService.getById(id);
employee.setLikes(employee.getLikes() + 1);
userService.updateById(employee);
return new Result<>(200, "点赞成功", "");
}
// 用户查看发给别人消息(finish)
@GetMapping("/sendToMessage")
public Result<List<Message>> sendToMessage(@RequestParam String toUserName) {
LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
userLambdaQueryWrapper.eq(User::getUserName, toUserName);
User toUser = userService.getOne(userLambdaQueryWrapper);
Long userId = GetIdUtil.getId();
LambdaQueryWrapper<Message> messageLambdaQueryWrapper = new LambdaQueryWrapper<>();
messageLambdaQueryWrapper.eq(Message::getSendUserId, userId)
.eq(Message::getGetUserId, toUser.getId());
List<Message> list = messageService.list(messageLambdaQueryWrapper);
return new Result<>(200, "", list);
}
// 用户查看别人发给自己的消息(finish)
@GetMapping("/getFromMessage")
public Result<List<Message>> getFromMessage(@RequestParam Long id) {
LambdaQueryWrapper<Message> messageLambdaQueryWrapper = new LambdaQueryWrapper<>();
messageLambdaQueryWrapper.eq(Message::getGetUserId, id);
messageLambdaQueryWrapper.orderByDesc(Message::getMark)
.orderByDesc(Message::getCreateTime);
List<Message> list = messageService.list(messageLambdaQueryWrapper);
return new Result<>(200, "", list);
}
// 用户确认查看消息(finish)
@PostMapping("/confirmMessage")
public Result<String> confirmMessage(@RequestParam Long id) {
Message message = messageService.getById(id);
message.setMark(0);
messageService.updateById(message);
return new Result<>(200, "消息查看成功", "");
}
// 用户删除聊天消息(finish)
@DeleteMapping("/deleteMsg")
public Result<String> deleteMessage(@RequestParam Long id) {
messageService.removeById(id);
return new Result<>(200, "消息删除成功", "");
}
// 用户新建快递地址(finish)
@PostMapping("/addAddress")
public Result<String> addAddress(@RequestBody @Validated Address address) {
// 查询快递地址是否已经存在
LambdaQueryWrapper<Address> addressLambdaQueryWrapper = new LambdaQueryWrapper<>();
addressLambdaQueryWrapper.eq(Address::getAddress, address.getAddress());
Address getAddress = addressService.getOne(addressLambdaQueryWrapper);
if (getAddress != null) {
return new Result<>(409, "该地址已存在", "");
}
addressService.save(address);
return new Result<>(200, "地址创建成功", "");
}
// 用户获取自己写过的地址(finish)
@GetMapping("/getAddress")
public Result<List<Address>> listAddress(@RequestParam Long id) {
LambdaQueryWrapper<Address> addressLambdaQueryWrapper = new LambdaQueryWrapper<>();
addressLambdaQueryWrapper.eq(Address::getUserId, id)
.orderByDesc(Address::getAddress);
List<Address> list = addressService.list(addressLambdaQueryWrapper);
return new Result<>(200, "", list);
}
// 用户获取自己所有的快递记录(finish)
@GetMapping("/history")
public Result<Page<RecordsListDTO>> getHistory(@RequestParam int page, @RequestParam int pageSize) {
if (page <= 0 || pageSize <= 0) {
return new Result<>(400, "页码和每页大小必须大于0", null);
}
Long userId = GetIdUtil.getId(); // 获取当前用户的ID
List<Records> recordsList = new ArrayList<>();
// 查询作为收件人的快递记录
LambdaQueryWrapper<Records> recordsLambdaQueryWrapper = new LambdaQueryWrapper<>();
recordsLambdaQueryWrapper.eq(Records::getGetUserId, userId);
// 添加排序条件
recordsLambdaQueryWrapper.orderByAsc(Records::getMark)
.orderByDesc(Records::getCreateTime);
List<Records> receivedRecords = recordsService.list(recordsLambdaQueryWrapper);
recordsLambdaQueryWrapper.clear();
recordsList.addAll(receivedRecords);
// 查询作为寄件人的快递记录
recordsLambdaQueryWrapper.eq(Records::getSendUserId, userId);
// 添加排序条件
recordsLambdaQueryWrapper.orderByAsc(Records::getMark)
.orderByDesc(Records::getCreateTime);
List<Records> sentRecords = recordsService.list(recordsLambdaQueryWrapper);
recordsList.addAll(sentRecords);
// 分页处理
int totalRecords = recordsList.size();
int fromIndex = Math.min(pageSize * (page - 1), totalRecords);
int toIndex = Math.min(fromIndex + pageSize, totalRecords);
List<Records> pagedRecords = recordsList.subList(fromIndex, toIndex);
// 封装成GoodsListDTO
List<RecordsListDTO> recordsListDTOList = new ArrayList<>();
for (Records records : pagedRecords) {
Goods goods = goodsService.getById(records.getGoodsId());
User sender = userService.getById(records.getSendUserId());
User recipient = userService.getById(records.getGetUserId());
User addressee = userService.getById(records.getAddresseeId());
User courier = userService.getById(records.getExpressId());
Address addressFrom = addressService.getById(records.getAddressFrom());
Address addressTo = addressService.getById(records.getAddressId());
LambdaQueryWrapper<Code> codeLambdaQueryWrapper = new LambdaQueryWrapper<>();
codeLambdaQueryWrapper.eq(Code::getGoodsId, goods.getId());
Code code = codeService.getOne(codeLambdaQueryWrapper);
RecordsListDTO recordsListDTO = new RecordsListDTO();
recordsListDTO.setGoods(goods);
recordsListDTO.setAddressFrom(addressFrom);
recordsListDTO.setAddressTo(addressTo);
recordsListDTO.setEmployee(courier);
recordsListDTO.setAddressee(addressee);
recordsListDTO.setSendUser(sender);
recordsListDTO.setGetUserId(recipient);
recordsListDTO.setCode(code);
recordsListDTO.setRecord(records);
recordsListDTOList.add(recordsListDTO);
}
Page<RecordsListDTO> goodsDTOPage = new Page<>(page, pageSize, totalRecords);
goodsDTOPage.setRecords(recordsListDTOList);
return new Result<>(200, "", goodsDTOPage);
}
// 用户寄件(完成)
@PostMapping("/shipment")
public Result<String> shipmentExpress(@RequestBody @Validated @NotNull GoodsDTO goodsDTO) {
// 判断用户是否存在
LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
userLambdaQueryWrapper.eq(User::getUserName, goodsDTO.getGetUserName());
User getUser = userService.getOne(userLambdaQueryWrapper);
if (getUser == null) {
return new Result<>(404, "用户不存在", null);
}
userLambdaQueryWrapper.clear();
// 判断地址是否存在
LambdaQueryWrapper<Address> addressLambdaQueryWrapper = new LambdaQueryWrapper<>();
addressLambdaQueryWrapper.eq(Address::getAddress, goodsDTO.getAddressTo());
Address address = addressService.getOne(addressLambdaQueryWrapper);
if (address == null) {
return new Result<>(404, "地址不存在", null);
}
addressLambdaQueryWrapper.clear();
// 如果寄件和收件是一个地方,禁止
if (goodsDTO.getAddressFrom().equals(goodsDTO.getAddressTo())) {
return new Result<>(400, "寄件和收件不能是同一个地方", null);
}
// 生成快递码
String expressCode = ExpressCodeUtil.getExpressCode(goodsDTO.getCompany());
// 生成取件码
String claimCode = ClaimCodeUtil.getClaimCode(goodsDTO.getCompany());
Goods goods = new Goods();
goods.setSendUserId(GetIdUtil.getId());
goods.setGetUserId(getUser.getId());
goods.setExpressCode(expressCode);
goods.setName(goodsDTO.getName());
goods.setQuality(goodsDTO.getQuality());
goodsService.save(goods);
// 存进历史记录
// 寄件方位置
addressLambdaQueryWrapper.eq(Address::getAddress, goodsDTO.getAddressFrom());
Address addressFrom = addressService.getOne(addressLambdaQueryWrapper);
Records records = new Records();
records.setAddressFrom(addressFrom.getId());
records.setSendUserId(GetIdUtil.getId());
records.setGetUserId(getUser.getId());
records.setAddressId(address.getId());
records.setGoodsId(goods.getId());
// 系统自动分配快递员
userLambdaQueryWrapper.eq(User::getMark, 1);
List<User> list = userService.list(userLambdaQueryWrapper);
Collections.shuffle(list);
User user = list.get(0);
records.setExpressId(user.getId());
recordsService.save(records);
Code code = new Code();
code.setClaim(claimCode);
code.setGoodsId(goods.getId());
codeService.save(code);
return new Result<>(200, "寄件成功", "");
}
// 用户收件(finish)
@PostMapping("/addressee")
public Result<String> addressee(@Validated @RequestBody AddresseeDTO addresseeDTO) {
// 判断是不是自己的快递
Long goodsId = addresseeDTO.getGoodsId();
Goods goods = goodsService.getById(goodsId);
if (goods.getGetUserId().compareTo(GetIdUtil.getId()) != 0) {
return new Result<>(401, "签收他人快递请选择代取功能", "");
}
QueryWrapper<Code> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("goods_id", goodsId);
Code code = codeService.getOne(queryWrapper);
// 判断取件码是否输入正确
if (!code.getClaim().equals(addresseeDTO.getClaimCode())) {
return new Result<>(401, "请输入正确的取件码", "");
}
QueryWrapper<Records> recordsQueryWrapper = new QueryWrapper<>();
recordsQueryWrapper.eq("goods_id", goodsId);
Records records = recordsService.getOne(recordsQueryWrapper);
records.setMark(1);
// 设置取件人
records.setAddresseeId(GetIdUtil.getId());
recordsService.updateById(records);
return new Result<>(200, "取件成功", "");
}
// 用户代取快递(finish)
@PostMapping("/pickUp")
public Result<String> pickUpExpress(@RequestBody @Validated PickUpExpressDTO pickUpExpressDTO) {
// 查询快递原主人信息
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("user_name", pickUpExpressDTO.getMaster());
User master = userService.getOne(userQueryWrapper);
if (master == null) {
return new Result<>(404, "该用户不存在", "");
}
// 查询快递信息
QueryWrapper<Goods> goodsQueryWrapper = new QueryWrapper<>();
goodsQueryWrapper.eq("express_code", pickUpExpressDTO.getExpressCode());
Goods goods = goodsService.getOne(goodsQueryWrapper);
if (goods == null) {
return new Result<>(404, "快递不存在", "");
}
// 代取
QueryWrapper<Records> recordsQueryWrapper = new QueryWrapper<>();
recordsQueryWrapper.eq("goods_id", goods.getId());
Records records = recordsService.getOne(recordsQueryWrapper);
if (records.getMark() == 1) {
return new Result<>(404, "快递已被签收", "");
}
records.setMark(1);
records.setAddresseeId(GetIdUtil.getId());
recordsService.updateById(records);
return new Result<>(200, "代取成功", "");
}
// 用户查询快递(完成)
@GetMapping("/query")
public Result<Goods> queryGoods(@RequestParam String queryCode, @RequestParam Long queryId) {
if (queryCode.isEmpty()) {
return new Result<>(400, "查询失败", null);
}
Long id = GetIdUtil.getId();
LambdaQueryWrapper<Goods> goodsLambdaQueryWrapper = new LambdaQueryWrapper<>();
if (Objects.equals(id, queryId)) {
goodsLambdaQueryWrapper.eq(Goods::getExpressCode, queryCode);
Goods goods = goodsService.getOne(goodsLambdaQueryWrapper);
return new Result<>(200, "查询成功", goods);
} else {
goodsLambdaQueryWrapper.eq(Goods::getExpressCode, queryCode)
.eq(Goods::getGetUserId, queryId);
Goods goods = goodsService.getOne(goodsLambdaQueryWrapper);
if (goods == null) {
return new Result<>(404, "请输入正确的快递单号, 或您不是快递的收件人或者邮寄人", null);
} else {
return new Result<>(200, "查询成功", goods);
}
}
}
// 用户查询用户信息(完成)
@GetMapping("/queryInfo")
public Result<String> queryInfo(@RequestParam Long otherId) {
User user = userService.getById(otherId);
return new Result<>(200, "", user.getUserName());
}
// 用户获取单个快递历史记录(完成)
@GetMapping("/singleHistory")
public Result<Records> singleHistory(@RequestParam String goodsId) {
LambdaQueryWrapper<Records> recordsLambdaQueryWrapper = new LambdaQueryWrapper<>();
recordsLambdaQueryWrapper.eq(Records::getGoodsId, goodsId);
Records records = recordsService.getOne(recordsLambdaQueryWrapper);
return new Result<>(200, "", records);
}
}

@ -0,0 +1,33 @@
package jty.expressdistributionsystem.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
@Data
@TableName("address")
public class Address implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
@TableId("id")
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
@TableField("user_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long userId;
@TableField("address")
@NotBlank(message = "地址不能为空")
private String address;
}

@ -0,0 +1,33 @@
package jty.expressdistributionsystem.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
@Data
@TableName("code")
public class Code implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
@TableId("id")
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
@TableField("goods_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long goodsId;
@TableField("claim")
@NotBlank(message = "取件码不能为空")
private String claim;
}

@ -0,0 +1,48 @@
package jty.expressdistributionsystem.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jty.expressdistributionsystem.validation.inter.ValidQuality;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
@TableName("goods")
@Data
public class Goods implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
@TableId("id")
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
@TableField("send_user_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long sendUserId;
@TableField("get_user_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long getUserId;
@TableField("express_code")
@NotBlank(message = "快递码未生成, 请重新填写信息")
private String expressCode;
@TableField("name")
@NotBlank(message = "快递名称不能为空")
private String name;
@TableField("quality")
@NotBlank(message = "快递重量不能为空")
@ValidQuality
private Double quality;
}

@ -0,0 +1,50 @@
package jty.expressdistributionsystem.entity;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import org.jetbrains.annotations.NotNull;
import java.io.Serial;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
@TableName("message")
public class Message implements Serializable {
public Message() {
}
@Serial
private static final long serialVersionUID = 1L;
@TableId("id")
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
@TableField("content")
private String content;
@TableField("send_user_id")
@NotNull
@JsonSerialize(using = ToStringSerializer.class)
private Long sendUserId;
@TableField("get_user_id")
@NotNull
@JsonSerialize(using = ToStringSerializer.class)
private Long getUserId;
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
@TableField("mark")
private Integer mark;
}

@ -0,0 +1,65 @@
package jty.expressdistributionsystem.entity;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
@TableName("records")
public class Records implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
@TableId("id")
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
@TableField("send_user_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long sendUserId;
@TableField("get_user_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long getUserId;
@TableField("express_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long expressId;
@TableField("goods_id")
@JsonSerialize(using = ToStringSerializer.class)
@NotNull
private Long goodsId;
@TableField("mark")
private Integer mark;
// 从哪里送的
@TableField("address_from")
@JsonSerialize(using = ToStringSerializer.class)
private Long addressFrom;
// 送到哪里
@TableField("address_id")
@JsonSerialize(using = ToStringSerializer.class)
private Long addressId;
@TableField("addressee_id")
@JsonSerialize(using = ToStringSerializer.class)
private Long addresseeId;
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package jty.expressdistributionsystem.entity;
import lombok.Data;
@Data
public class Result<T> {
private int code;
private String message;
private T data;
public Result(int code, String message, T data) {
this.code = code;
this.message = message;
this.data = data;
}
}

@ -0,0 +1,69 @@
package jty.expressdistributionsystem.entity;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
@TableName("user")
public class User implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
@TableId("id")
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
@TableField("user_name")
@NotBlank(message = "用户名不能为空")
private String userName;
@TableField("account")
@NotBlank(message = "账号不能为空")
@Pattern(regexp = "^(?!\\s)([A-Za-z0-9]{1,10})$", message = "账号长度在1-10位之间")
private String account;
@TableField("phone")
@NotBlank(message = "手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号有误")
private String phone;
@TableField("password")
@NotBlank(message = "密码不能为空")
@Pattern(regexp = "^.+$", message = "密码不能为空")
private String password;
@TableField("identity")
@NotBlank(message = "身份证不能为空")
@Pattern(regexp = "^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\\d{3}(\\d|X|x)$",
message = "身份证有误")
private String identity;
@TableField("mark")
private Integer mark;
@TableField("likes")
private Integer likes;
@TableField("disabled")
private Integer disabled;
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
@TableField(value = "login_time")
private LocalDateTime loginTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
}

@ -0,0 +1,22 @@
package jty.expressdistributionsystem.interceptors;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import java.util.HashMap;
import java.util.Map;
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<Map<String, String>> handleValidationExceptions(MethodArgumentNotValidException ex) {
Map<String, String> errors = new HashMap<>();
ex.getBindingResult().getFieldErrors().forEach(error ->
errors.put(error.getField(), error.getDefaultMessage())
);
return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);
}
}

@ -0,0 +1,52 @@
package jty.expressdistributionsystem.interceptors;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jty.expressdistributionsystem.utils.JwtUtil;
import jty.expressdistributionsystem.utils.ThreadLocalUtil;
import org.jetbrains.annotations.NotNull;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import java.util.Map;
//注入到IOC容器
@Component
public class LoginInterceptor implements HandlerInterceptor {
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public boolean preHandle(HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler) {
// 令牌验证
String token = request.getHeader("Authorization");
try {
// 从redis获取相同的token
ValueOperations<String, String> stringStringValueOperations = stringRedisTemplate.opsForValue();
String redisToken = stringStringValueOperations.get(token);
if (redisToken == null) {
// 说明token失效
throw new RuntimeException();
}
Map<String, Object> claims = JwtUtil.parseToken(token);
// 把数据存储到ThreadLocal当中
ThreadLocalUtil.set(claims);
// 放行
return true;
} catch (Exception e) {
// http响应状态码为401
response.setStatus(401);
// 不放行
return false;
}
}
@Override
public void afterCompletion(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler, Exception ex) {
// 清空ThreadLocal当中的数据防止内存泄露
ThreadLocalUtil.remove();
}
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jty.expressdistributionsystem.entity.Address;
public interface AddressMapper extends BaseMapper<Address> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jty.expressdistributionsystem.entity.Code;
public interface CodeMapper extends BaseMapper<Code> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jty.expressdistributionsystem.entity.Goods;
public interface GoodsMapper extends BaseMapper<Goods> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jty.expressdistributionsystem.entity.Message;
public interface MessageMapper extends BaseMapper<Message> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jty.expressdistributionsystem.entity.Records;
public interface RecordsMapper extends BaseMapper<Records> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jty.expressdistributionsystem.entity.User;
public interface UserMapper extends BaseMapper<User> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.service;
import com.baomidou.mybatisplus.extension.service.IService;
import jty.expressdistributionsystem.entity.Address;
public interface AddressService extends IService<Address> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.service;
import com.baomidou.mybatisplus.extension.service.IService;
import jty.expressdistributionsystem.entity.Code;
public interface CodeService extends IService<Code> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.service;
import com.baomidou.mybatisplus.extension.service.IService;
import jty.expressdistributionsystem.entity.Goods;
public interface GoodsService extends IService<Goods> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.service;
import com.baomidou.mybatisplus.extension.service.IService;
import jty.expressdistributionsystem.entity.Message;
public interface MessageService extends IService<Message> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.service;
import com.baomidou.mybatisplus.extension.service.IService;
import jty.expressdistributionsystem.entity.Records;
public interface RecordsService extends IService<Records> {
}

@ -0,0 +1,7 @@
package jty.expressdistributionsystem.service;
import com.baomidou.mybatisplus.extension.service.IService;
import jty.expressdistributionsystem.entity.User;
public interface UserService extends IService<User> {
}

@ -0,0 +1,11 @@
package jty.expressdistributionsystem.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jty.expressdistributionsystem.entity.Address;
import jty.expressdistributionsystem.mapper.AddressMapper;
import jty.expressdistributionsystem.service.AddressService;
import org.springframework.stereotype.Service;
@Service
public class AddressServiceImpl extends ServiceImpl<AddressMapper, Address> implements AddressService {
}

@ -0,0 +1,11 @@
package jty.expressdistributionsystem.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jty.expressdistributionsystem.entity.Code;
import jty.expressdistributionsystem.mapper.CodeMapper;
import jty.expressdistributionsystem.service.CodeService;
import org.springframework.stereotype.Service;
@Service
public class CodeServiceImpl extends ServiceImpl<CodeMapper, Code> implements CodeService {
}

@ -0,0 +1,11 @@
package jty.expressdistributionsystem.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jty.expressdistributionsystem.entity.Goods;
import jty.expressdistributionsystem.mapper.GoodsMapper;
import jty.expressdistributionsystem.service.GoodsService;
import org.springframework.stereotype.Service;
@Service
public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements GoodsService {
}

@ -0,0 +1,11 @@
package jty.expressdistributionsystem.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jty.expressdistributionsystem.entity.Message;
import jty.expressdistributionsystem.mapper.MessageMapper;
import jty.expressdistributionsystem.service.MessageService;
import org.springframework.stereotype.Service;
@Service
public class MessageServiceImpl extends ServiceImpl<MessageMapper, Message> implements MessageService {
}

@ -0,0 +1,11 @@
package jty.expressdistributionsystem.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jty.expressdistributionsystem.entity.Records;
import jty.expressdistributionsystem.mapper.RecordsMapper;
import jty.expressdistributionsystem.service.RecordsService;
import org.springframework.stereotype.Service;
@Service
public class RecordsServiceImpl extends ServiceImpl<RecordsMapper, Records> implements RecordsService {
}

@ -0,0 +1,11 @@
package jty.expressdistributionsystem.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jty.expressdistributionsystem.entity.User;
import jty.expressdistributionsystem.mapper.UserMapper;
import jty.expressdistributionsystem.service.UserService;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

@ -0,0 +1,19 @@
package jty.expressdistributionsystem.utils;
import org.jetbrains.annotations.NotNull;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
public class ClaimCodeUtil {
public static @NotNull String getClaimCode(String company) {
// 获取当前时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String timeStamp = sdf.format(new Date());
// 生成唯一标识符
String uniqueId = UUID.randomUUID().toString().replace("-", "").substring(0, 6);
// 将公司名、时间戳和唯一ID组合成取件码
return company.toUpperCase() + timeStamp + uniqueId;
}
}

@ -0,0 +1,18 @@
package jty.expressdistributionsystem.utils;
import org.jetbrains.annotations.NotNull;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
public class ExpressCodeUtil {
public static @NotNull String getExpressCode(String company) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String timeStamp = sdf.format(new Date());
// 生成唯一标识符
String uniqueId = UUID.randomUUID().toString().replace("-", "").substring(0, 8);
// 将公司名、时间戳和唯一ID组合成快递码
return company.toUpperCase() + timeStamp + uniqueId;
}
}

@ -0,0 +1,11 @@
package jty.expressdistributionsystem.utils;
import java.util.Map;
public class GetIdUtil {
private static final Map<String, Object> claims = ThreadLocalUtil.get();
public static Long getId() {
return (Long) claims.get("id");
}
}

@ -0,0 +1,34 @@
package jty.expressdistributionsystem.utils;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.util.Date;
import java.util.Map;
/**
* JWT
*/
public class JwtUtil {
private static final String KEY = "catSys";
// 接收业务数据,生成token并返回
public static String genToken(Map<String, Object> claims) {
return JWT.create()
.withClaim("claims", claims)
// 一天过期
.withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24))
.sign(Algorithm.HMAC256(KEY));
}
// 接收token,验证token,并返回业务数据
public static Map<String, Object> parseToken(String token) {
return JWT.require(Algorithm.HMAC256(KEY))
.build()
.verify(token)
.getClaim("claims")
.asMap();
}
}

@ -0,0 +1,56 @@
package jty.expressdistributionsystem.utils;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class Md5Util {
protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
protected static MessageDigest messagedigest = null;
static {
try {
messagedigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException nsaex) {
System.err.println(Md5Util.class.getName() + "初始化失败MessageDigest不支持MD5Util。");
nsaex.printStackTrace();
}
}
public static String getMD5String(String s) {
return getMD5String(s.getBytes());
}
public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password);
return s.equals(md5PwdStr);
}
public static String getMD5String(byte[] bytes) {
messagedigest.update(bytes);
return bufferToHex(messagedigest.digest());
}
private static String bufferToHex(byte bytes[]) {
return bufferToHex(bytes, 0, bytes.length);
}
private static String bufferToHex(byte bytes[], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n;
for (int l = m; l < k; l++) {
appendHexPair(bytes[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
char c0 = hexDigits[(bt & 0xf0) >> 4];
char c1 = hexDigits[bt & 0xf];
stringbuffer.append(c0);
stringbuffer.append(c1);
}
}

@ -0,0 +1,23 @@
package jty.expressdistributionsystem.utils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import jty.expressdistributionsystem.DTO.SendMessageDTO;
import jty.expressdistributionsystem.entity.Message;
import jty.expressdistributionsystem.entity.User;
import jty.expressdistributionsystem.service.UserService;
import org.jetbrains.annotations.NotNull;
public class SendMessageUtil {
public static Message sendMessage(@NotNull SendMessageDTO sendMessageDTO, UserService userService) {
Long sendId = GetIdUtil.getId();
Message message = new Message();
message.setSendUserId(sendId);
LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
userLambdaQueryWrapper.eq(User::getUserName, sendMessageDTO.getToUserName());
User user = userService.getOne(userLambdaQueryWrapper);
message.setGetUserId(user.getId());
message.setContent(sendMessageDTO.getContent());
return message;
}
}

@ -0,0 +1,25 @@
package jty.expressdistributionsystem.utils;
/**
* 便Id
*/
@SuppressWarnings("all")
public class ThreadLocalUtil {
//提供ThreadLocal对象
private static final ThreadLocal THREAD_LOCAL = new ThreadLocal();
//根据键获取值
public static <T> T get() {
return (T) THREAD_LOCAL.get();
}
//存储键值对
public static void set(Object value) {
THREAD_LOCAL.set(value);
}
//清除ThreadLocal 防止内存泄漏
public static void remove() {
THREAD_LOCAL.remove();
}
}

@ -0,0 +1,13 @@
package jty.expressdistributionsystem.validation;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import jty.expressdistributionsystem.validation.inter.ValidQuality;
public class QualityValidator implements ConstraintValidator<ValidQuality, Double> {
@Override
public boolean isValid(Double value, ConstraintValidatorContext context) {
return value != null && value > 0; // 确保数值不为null且大于0
}
}

@ -0,0 +1,21 @@
package jty.expressdistributionsystem.validation.inter;
import jakarta.validation.Constraint;
import jakarta.validation.Payload;
import jty.expressdistributionsystem.validation.QualityValidator;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Constraint(validatedBy = QualityValidator.class) // 指定验证器
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE, ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidQuality {
String message() default "快递重量必须大于0";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}

@ -0,0 +1,29 @@
server:
port: 5678
spring:
application:
#应用名称
name: ExpressSys
datasource:
#配置数据库信息
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/distribution?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
username: root
password: Grs20021127
#redis
data:
redis:
host: localhost
port: 6379
mybatis-plus:
configuration:
#开启驼峰
map-underscore-to-camel-case: true
#日志
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
global-config:
db-config:
#雪花id
id-type: ASSIGN_ID

@ -0,0 +1,13 @@
package jty.expressdistributionsystem;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class ExpressDistributionSystemApplicationTests {
@Test
void contextLoads() {
}
}
Loading…
Cancel
Save