Compare commits

...

33 Commits

Author SHA1 Message Date
m4bagu2fl b767462b94 Merge pull request 'final' (#10) from develop into main
7 months ago
m4bagu2fl 67c0ba3094 Merge pull request 'zhaoyuyan_zhushi' (#9) from branch_zhaoyuyan into develop
7 months ago
wdt 0492dcf3f8 init
7 months ago
wdt aabf03cda2 init
7 months ago
wdt bbe3802164 init
7 months ago
wdt 775fa7597a init
7 months ago
YOUR_USERNAME cb6babc47d zhaoyuyan_server
7 months ago
YOUR_USERNAME 46a6a42652 zhaoyuyan_pojo
7 months ago
YOUR_USERNAME 625199757b zhaoyuyan_common
7 months ago
wdt 67ef88efbf init
7 months ago
wdt 2761a8f351 change
7 months ago
YOUR_USERNAME f5070ad35c zhaoyuyan_server
7 months ago
YOUR_USERNAME 34784361a8 zhaoyuyan_pojo
7 months ago
YOUR_USERNAME 017cedb985 zhaoyuyan_common
7 months ago
m4bagu2fl be5b38751a Merge pull request 'wuyuxin_zhushi' (#6) from develop into main
7 months ago
m4bagu2fl 25bfb48146 Merge pull request 'wuyuxin_zhushi' (#5) from branch_wuyuxin into develop
7 months ago
wdt 8ffac5e359 change readme
7 months ago
m4bagu2fl c35e8d8a2f Merge pull request 'second' (#4) from develop into main
7 months ago
m4bagu2fl 74b99ae1b3 Merge pull request 'wangheng_zhushi' (#3) from branch_wangheng into develop
7 months ago
m4bagu2fl a3ccaac237 Merge pull request 'wudengtao_zhushi' (#2) from branch_wudengtao into develop
7 months ago
wdt 866a9adf27 Merge branch 'develop' of https://bdgit.educoder.net/m4bagu2fl/homework
7 months ago
wdt ff9d7626b5 w_sky_server
7 months ago
wangheng 5869978929 test03
7 months ago
wangheng 8328fa6167 test02
7 months ago
wdt 3a224593c3 w_sky_pojo
7 months ago
wangheng 2f583b24d3 test01
7 months ago
wangheng 43b551d603 test00
7 months ago
ZHAOYUYAN 2214c87ef7 zhaoyuyan
7 months ago
wdt e002d6f715 w_sky_common
7 months ago
wdt 4880bc2947 w_init
7 months ago
wdt 03669b0cf5 w_init
7 months ago
m4bagu2fl 6d9f0c6a8c Delete 'README.md'
7 months ago
m4bagu2fl c1a8d47aa1 Initial commit
7 months ago

@ -1,20 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RemoteRepositoriesConfiguration">
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Central Repository" />
<option name="url" value="https://repo.maven.apache.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Maven Central repository" />
<option name="url" value="https://repo1.maven.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="jboss.community" />
<option name="name" value="JBoss Community repository" />
<option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
</remote-repository>
</component>
</project>

@ -1,14 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project version="4"> <project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" /> <component name="ProjectRootManager">
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/sky/pom.xml" />
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" /> <output url="file://$PROJECT_DIR$/out" />
</component> </component>
</project> </project>

@ -2,7 +2,7 @@
<project version="4"> <project version="4">
<component name="ProjectModuleManager"> <component name="ProjectModuleManager">
<modules> <modules>
<module fileurl="file://$PROJECT_DIR$/.idea/cangqiong-takeout-master.iml" filepath="$PROJECT_DIR$/.idea/cangqiong-takeout-master.iml" /> <module fileurl="file://$PROJECT_DIR$/.idea/homework.iml" filepath="$PROJECT_DIR$/.idea/homework.iml" />
</modules> </modules>
</component> </component>
</project> </project>

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project version="4"> <project version="4">
<component name="VcsDirectoryMappings"> <component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" /> <mapping directory="" vcs="Git" />
</component> </component>
</project> </project>

@ -0,0 +1,109 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="AutoImportSettings">
<option name="autoReloadType" value="SELECTIVE" />
</component>
<component name="ChangeListManager">
<list default="true" id="4e31bd9e-b27b-473d-8d9f-11aae099774a" name="更改" comment="init" />
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
<option name="LAST_RESOLUTION" value="IGNORE" />
</component>
<component name="Git.Settings">
<option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
</component>
<component name="MarkdownSettingsMigration">
<option name="stateVersion" value="1" />
</component>
<component name="ProjectId" id="2qMnnEMaBral5NxjSrqulllL9dd" />
<component name="ProjectViewState">
<option name="hideEmptyMiddlePackages" value="true" />
<option name="showLibraryContents" value="true" />
</component>
<component name="PropertiesComponent"><![CDATA[{
"keyToString": {
"RunOnceActivity.OpenProjectViewOnStart": "true",
"RunOnceActivity.ShowReadmeOnStart": "true",
"WebServerToolWindowFactoryState": "false",
"node.js.detected.package.eslint": "true",
"node.js.detected.package.tslint": "true",
"node.js.selected.package.eslint": "(autodetect)",
"node.js.selected.package.tslint": "(autodetect)",
"nodejs_package_manager_path": "npm",
"vue.rearranger.settings.migration": "true"
}
}]]></component>
<component name="RunManager">
<configuration default="true" type="JetRunConfigurationType">
<module name="homework" />
<method v="2">
<option name="Make" enabled="true" />
</method>
</configuration>
<configuration default="true" type="KotlinStandaloneScriptRunConfigurationType">
<module name="homework" />
<option name="filePath" />
<method v="2">
<option name="Make" enabled="true" />
</method>
</configuration>
</component>
<component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="应用程序级" UseSingleDictionary="true" transferred="true" />
<component name="TaskManager">
<task active="true" id="Default" summary="默认任务">
<changelist id="4e31bd9e-b27b-473d-8d9f-11aae099774a" name="更改" comment="" />
<created>1734481479677</created>
<option name="number" value="Default" />
<option name="presentableId" value="Default" />
<updated>1734481479677</updated>
<workItem from="1734481481002" duration="215000" />
<workItem from="1734481709837" duration="161000" />
<workItem from="1734481891271" duration="303000" />
</task>
<task id="LOCAL-00001" summary="init">
<option name="closed" value="true" />
<created>1734481658673</created>
<option name="number" value="00001" />
<option name="presentableId" value="LOCAL-00001" />
<option name="project" value="LOCAL" />
<updated>1734481658673</updated>
</task>
<task id="LOCAL-00002" summary="init">
<option name="closed" value="true" />
<created>1734481925729</created>
<option name="number" value="00002" />
<option name="presentableId" value="LOCAL-00002" />
<option name="project" value="LOCAL" />
<updated>1734481925729</updated>
</task>
<task id="LOCAL-00003" summary="init">
<option name="closed" value="true" />
<created>1734481967448</created>
<option name="number" value="00003" />
<option name="presentableId" value="LOCAL-00003" />
<option name="project" value="LOCAL" />
<updated>1734481967448</updated>
</task>
<option name="localTasksCounter" value="4" />
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
<option name="version" value="3" />
</component>
<component name="Vcs.Log.Tabs.Properties">
<option name="TAB_STATES">
<map>
<entry key="MAIN">
<value>
<State />
</value>
</entry>
</map>
</option>
</component>
<component name="VcsManagerConfiguration">
<MESSAGE value="init" />
<option name="LAST_COMMIT_MESSAGE" value="init" />
</component>
</project>

@ -1,8 +1,6 @@
<<<<<<< HEAD
# 苍穹外卖
#### 介绍 #### 介绍
黑马苍穹外卖项目源码,已完结 外卖项目源码
#### 软件架构 #### 软件架构
软件架构说明 软件架构说明

@ -0,0 +1,36 @@
package com.sky.constant;
/**
*
* <p>
*
*/
public class AutoFillConstant {
/**
*
* <p>
* 使
*/
public static final String SET_CREATE_TIME = "setCreateTime";
/**
*
* <p>
* 使
*/
public static final String SET_UPDATE_TIME = "setUpdateTime";
/**
*
* <p>
* 使
*/
public static final String SET_CREATE_USER = "setCreateUser";
/**
*
* <p>
* 使
*/
public static final String SET_UPDATE_USER = "setUpdateUser";
}

@ -0,0 +1,43 @@
/**
* JwtClaimsConstant JWTJSON Web Tokensclaims
* JWT 使
*/
package com.sky.constant;
import java.time.LocalDateTime;
public class JwtClaimsConstant {
/**
* ID
* JWT
*/
public static final String EMP_ID = "empId";
/**
* ID
* JWT
*/
public static final String USER_ID = "userId";
// 下面的常量被注释掉了,如果需要使用,可以取消注释并添加相应的文档注释。
/*
*
* JWT
* public static final String PHONE = "phone";
*/
/*
*
* JWT
* public static final String USERNAME = "username";
*/
/*
*
* JWT
* public static final String NAME = "name";
*/
}

@ -0,0 +1,16 @@
package com.sky.constant;
/**
*
* 便
*/
public class PasswordConstant {
/**
* 使 "123456"
*
* 使
*/
public static final String DEFAULT_PASSWORD = "123456";
}

@ -0,0 +1,23 @@
package com.sky.constant;
/**
*
* <p>
* ENABLEDISABLE
*/
public class StatusConstant {
/**
*
* <p>
* 使
*/
public static final Integer ENABLE = 1;
/**
*
* <p>
* 使
*/
public static final Integer DISABLE = 0;
}

@ -0,0 +1,43 @@
package com.sky.context;
/**
* BaseContext ThreadLocal 线
* 线
*/
public class BaseContext {
/**
* threadLocal ThreadLocal 线
* 线线
*/
private static ThreadLocal<Long> threadLocal = new ThreadLocal<>();
/**
* 线ID
* IDIDID
*
* @param id ID
*/
public static void setCurrentId(Long id) {
threadLocal.set(id);
}
/**
* 线ID
* 线ID null
*
* @return 线ID
*/
public static Long getCurrentId() {
return threadLocal.get();
}
/**
* 线ID
* 线
*/
public static void removeCurrentId() {
threadLocal.remove();
}
}

@ -0,0 +1,28 @@
package com.sky.exception;
/**
*
*
* BaseException便
*/
public class AccountLockedException extends BaseException {
/**
*
* 使
*/
public AccountLockedException() {
}
/**
*
* msg
* 便BaseException
*
* @param msg
*/
public AccountLockedException(String msg) {
super(msg);
}
}

@ -0,0 +1,27 @@
package com.sky.exception;
/**
*
* <p>
* 访
*/
public class AccountNotFoundException extends BaseException {
/**
*
* <p>
* 使
*/
public AccountNotFoundException() {
super();
}
/**
*
*
* @param msg
*/
public AccountNotFoundException(String msg) {
super(msg);
}
}

@ -0,0 +1,19 @@
package com.sky.exception;
/**
* AddressBookBusinessException 簿
* BaseException使簿
*/
public class AddressBookBusinessException extends BaseException {
/**
* AddressBookBusinessException
*
* @param msg
* 便
*/
public AddressBookBusinessException(String msg) {
super(msg); // 调用父类 BaseException 的构造函数,传递错误信息。
}
}

@ -0,0 +1,22 @@
package com.sky.exception;
/**
*
*
*
* BaseException便
*/
public class DeletionNotAllowedException extends BaseException {
/**
*
* msg
*
* BaseException便
*
* @param msg
*/
public DeletionNotAllowedException(String msg) {
super(msg);
}
}

@ -0,0 +1,17 @@
package com.sky.exception;
/**
*
* <p>
*
*/
public class LoginFailedException extends BaseException {
/**
*
*
* @param msg
*/
public LoginFailedException(String msg) {
super(msg);
}
}

@ -0,0 +1,19 @@
package com.sky.exception;
/**
* OrderBusinessException
* BaseException使
*/
public class OrderBusinessException extends BaseException {
/**
* OrderBusinessException
*
* @param msg
* 便
*/
public OrderBusinessException(String msg) {
super(msg); // 调用父类 BaseException 的构造函数,传递错误信息。
}
}

@ -0,0 +1,30 @@
package com.sky.exception;
/**
*
*
* BaseException便
*/
public class PasswordErrorException extends BaseException {
/**
*
* 使
*
*/
public PasswordErrorException() {
}
/**
*
* msg
* BaseException
* 便
*
* @param msg
*/
public PasswordErrorException(String msg) {
super(msg);
}
}

@ -0,0 +1,27 @@
package com.sky.exception;
/**
*
* <p>
*
*/
public class SetmealEnableFailedException extends BaseException {
/**
*
* <p>
* 使
*/
public SetmealEnableFailedException() {
super();
}
/**
*
*
* @param msg
*/
public SetmealEnableFailedException(String msg) {
super(msg);
}
}

@ -0,0 +1,19 @@
package com.sky.exception;
/**
* ShoppingCartBusinessException
* BaseException使
*/
public class ShoppingCartBusinessException extends BaseException {
/**
* ShoppingCartBusinessException
*
* @param msg
*
*/
public ShoppingCartBusinessException(String msg) {
super(msg); // 调用父类 BaseException 的构造函数,并传递错误消息。
}
}

@ -0,0 +1,77 @@
package com.sky.json;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
/**
* JacksonObjectMapperObjectMapperJavaJSONJackson
* JSONJava [JSONJava]JavaJSON [JavaJSON]
* JSONJava
*/
public class JacksonObjectMapper extends ObjectMapper {
/**
* LocalDate "yyyy-MM-dd"
* 便JSONJavaLocalDate
*/
public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
/**
* "yyyy-MM-dd HH:mm:ss" "yyyy-MM-dd HH:mm"LocalDateTime
* 便
*/
public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm";
/**
* LocalTime "HH:mm:ss"
* JSONJava
*/
public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
/**
* JacksonObjectMapper
*/
public JacksonObjectMapper() {
super();
// 配置在接收到未知属性时不报异常的特性。
// 在JSON数据转换为Java对象时如果JSON中包含了Java对象对应类中不存在的属性默认情况下Jackson会抛出异常
// 通过设置此项为false使得在遇到这种情况时能够进行兼容处理避免因未知属性导致转换失败提高了对不同格式JSON数据的兼容性。
this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);
// 进一步设置反序列化时属性不存在的兼容处理。
// 确保在反序列化过程中即使遇到JSON中的属性在Java对象对应类里不存在的情况也能平稳进行处理不会因这种差异而中断转换流程
// 这是对反序列化兼容性的再次强化和上面的配置一起保障了在接收不同结构JSON数据时的稳健性。
this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
SimpleModule simpleModule = new SimpleModule()
// 为LocalDateTime类型添加反序列化器使用指定的日期时间格式由DEFAULT_DATE_TIME_FORMAT定义来解析JSON中的日期时间字符串将其转换为Java的LocalDateTime对象。
.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
// 为LocalDate类型添加反序列化器按照默认的日期格式DEFAULT_DATE_FORMAT把JSON中的日期字符串反序列化为Java的LocalDate对象。
.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
// 为LocalTime类型添加反序列化器依据默认的时间格式DEFAULT_TIME_FORMAT将JSON中的时间字符串转换为Java的LocalTime对象。
.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))
// 为LocalDateTime类型添加序列化器将Java的LocalDateTime对象按照指定的日期时间格式DEFAULT_DATE_TIME_FORMAT转换为JSON中的日期时间字符串进行输出。
.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
// 为LocalDate类型添加序列化器把Java的LocalDate对象依照默认的日期格式DEFAULT_DATE_FORMAT序列化为JSON中的日期字符串。
.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
// 为LocalTime类型添加序列化器使用默认的时间格式DEFAULT_TIME_FORMAT将Java的LocalTime对象转换为JSON中的时间字符串方便在JSON数据中呈现。
.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
// 注册功能模块通过注册这个自定义的SimpleModule使得添加的针对时间类型的序列化器和反序列化器生效
// 同时也可以在后续根据需要添加更多自定义的序列化器和反序列化器扩展该对象映射器的功能以满足不同业务场景下对JSON与Java对象转换的特殊要求。
this.registerModule(simpleModule);
}
}

@ -0,0 +1,42 @@
package com.sky.properties;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* OSS
* <p>
* OSS
*/
@Component
@ConfigurationProperties(prefix = "sky.alioss") // 指定配置文件中相关属性的前缀
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
public class AliOssProperties {
/**
* OSS
*/
private String endpoint;
/**
* 访ID
*/
private String accessKeyId;
/**
* 访
*/
private String accessKeySecret;
/**
*
*/
private String bucketName;
/**
*
*/
private String uploadPath;
}

@ -0,0 +1,53 @@
package com.sky.properties;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* JwtProperties JWTJSON Web Tokens
* Spring Boot @ConfigurationProperties application.properties application.yml
*/
@Component
@ConfigurationProperties(prefix = "sky.jwt") // 指定配置文件中属性的前缀
@Data
public class JwtProperties {
/**
* adminSecretKey JWT
* JWT
*/
private String adminSecretKey;
/**
* adminTtl JWT
*
*/
private long adminTtl;
/**
* adminTokenName JWT
* HTTP JWT
*/
private String adminTokenName;
/**
* userSecretKey JWT
*
* JWT
*/
private String userSecretKey;
/**
* userTtl JWT
*
*/
private long userTtl;
/**
* userTokenName JWT
* HTTP JWT
*/
private String userTokenName;
}

@ -0,0 +1,74 @@
package com.sky.properties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* WeChatProperties便
* 使Springapplication.propertiesapplication.yml便使
*/
@Component
@ConfigurationProperties(prefix = "sky.wechat")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class WeChatProperties {
/**
* appid
* appid
*/
private String appid;
/**
*
* 访access token访
*/
private String secret;
/**
*
* 退
*/
private String mchid;
/**
* APIAPI
* 使
*/
private String mchSerialNo;
/**
*
* 使
*/
private String privateKeyFilePath;
/**
*
* 使使使
*/
private String apiV3Key;
/**
*
*
*/
private String weChatPayCertFilePath;
/**
* URL
* 便
*/
private String notifyUrl;
/**
* 退退退URL
* 退退退
*/
private String refundNotifyUrl;
}

@ -0,0 +1,34 @@
package com.sky.result;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
@AllArgsConstructor // 使用lombok提供的注解来自动生成包含所有参数的构造函数
@NoArgsConstructor // 使用lombok提供的注解来自动生成无参数的构造函数
public class PageResult implements Serializable {
/**
*
* <p>
*
*/
private long total; // 总记录数
/**
*
* <p>
*
*/
private List records; // 当前页数据集合
}

@ -0,0 +1,76 @@
package com.sky.result;
import lombok.Data;
import java.io.Serializable;
/**
* Result
* Serializable 便
*
* @param <T>
*/
@Data
public class Result<T> implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号,用于确保反序列化时的兼容性
/**
* 1 0
*
*/
private Integer code;
/**
*
* 便
*/
private String msg;
/**
*
*
*/
private T data;
/**
* Result
*
* @param <T>
* @return Result 1
*/
public static <T> Result<T> success() {
Result<T> result = new Result<T>();
result.code = 1; // 设置状态码为成功
return result;
}
/**
* Result
*
* @param object
* @param <T>
* @return Result 1
*/
public static <T> Result<T> success(T object) {
Result<T> result = new Result<T>();
result.data = object; // 设置返回的数据
result.code = 1; // 设置状态码为成功
return result;
}
/**
* Result
*
* @param msg
* @param <T>
* @return Result 0
*/
public static <T> Result<T> error(String msg) {
Result<T> result = new Result<T>();
result.msg = msg; // 设置错误信息
result.code = 0; // 设置状态码为失败
return result;
}
}

@ -0,0 +1,205 @@
package com.sky.utils;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* HttpClientUtilHttpJava便HTTPGETPOST
* HTTP使便HTTP
*/
public class HttpClientUtil {
/**
* 55 * 1000HTTP
*
*/
static final int TIMEOUT_MSEC = 5 * 1000;
/**
* GETURLGET
*
* @param url url访API
* @param paramMap Map便
* @return JSONHTML
*/
public static String doGet(String url, Map<String, String> paramMap) {
// 创建Httpclient对象通过HttpClients.createDefault()方法获取默认配置的可关闭的HttpClient实例用于后续发起HTTP请求它是整个请求操作的基础客户端对象。
CloseableHttpClient httpClient = HttpClients.createDefault();
String result = "";
CloseableHttpResponse response = null;
try {
// 创建URIBuilder对象用于构建完整的URI统一资源标识符可以方便地在给定基础URL的基础上添加各种参数构造出符合要求的请求地址。
URIBuilder builder = new URIBuilder(url);
if (paramMap!= null) {
// 遍历请求参数Map将每个参数添加到URIBuilder中使其构建的URI包含相应的查询参数按照参数名和参数值的对应关系进行添加形成完整的带参请求地址。
for (String key : paramMap.keySet()) {
builder.addParameter(key, paramMap.get(key));
}
}
// 根据构建好的URIBuilder生成最终的URI对象该对象完整地描述了请求的目标资源位置及相关参数信息。
URI uri = builder.build();
// 创建GET请求对象使用生成的URI来初始化HttpGet实例明确此次请求的方式为GET以及请求的具体目标地址。
HttpGet httpGet = new HttpGet(uri);
// 发送请求通过之前创建的HttpClient实例执行HttpGet请求获取服务器返回的响应对象CloseableHttpResponse此对象包含了响应的状态码、响应头以及响应体等重要信息。
response = httpClient.execute(httpGet);
// 判断响应状态获取响应的状态码若状态码为200表示请求成功此时将响应体内容通过EntityUtils.toString方法指定编码为"UTF-8"读取出来赋值给result变量作为最终的响应结果返回若状态码不是200则返回空字符串。
if (response.getStatusLine().getStatusCode() == 200) {
result = EntityUtils.toString(response.getEntity(), "UTF-8");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// 关闭响应对象,释放相关资源,避免资源泄漏,无论请求是否成功都需要执行此操作。
response.close();
// 关闭HttpClient对象释放其占用的网络连接等资源确保程序的资源管理良好。
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
/**
* POSTPOSTURLPOSTIO
*
* @param url URLGETurl
* @param paramMap MapPOST
* @return POST
* @throws IOException I/O
*/
public static String doPost(String url, Map<String, String> paramMap) throws IOException {
// 创建Httpclient对象获取默认配置的可关闭的HttpClient实例用于后续发起HTTP的POST请求操作作为请求的客户端基础对象。
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
String resultString = "";
try {
// 创建Http Post请求对象使用给定的URL初始化HttpPost实例明确此次请求的方式为POST以及请求的目标地址后续将在此基础上添加请求参数等内容。
HttpPost httpPost = new HttpPost(url);
// 创建参数列表若传入的请求参数Map不为空则遍历该Map将每个参数转换为NameValuePair对象并添加到List中NameValuePair用于表示键值对形式的参数方便后续构建表单形式的请求实体。
if (paramMap!= null) {
List<NameValuePair> paramList = new ArrayList<>();
for (Map.Entry<String, String> param : paramMap.entrySet()) {
paramList.add(new BasicNameValuePair(param.getKey(), param.getValue()));
}
// 模拟表单通过将参数列表转换为UrlEncodedFormEntity对象来构建表单形式的请求实体它会对参数进行适当的编码处理例如对中文等特殊字符进行URL编码符合HTTP表单提交的规范然后将该请求实体设置到HttpPost请求对象中使得请求携带相应的参数信息。
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
httpPost.setEntity(entity);
}
// 设置请求配置通过调用builderRequestConfig方法构建请求配置对象并设置到HttpPost请求中该配置包含了连接超时时间、请求获取连接的超时时间以及套接字超时时间等设置确保请求在合理的时间范围内进行避免长时间等待。
httpPost.setConfig(builderRequestConfig());
// 执行http请求使用HttpClient实例执行HttpPost请求获取服务器返回的响应对象CloseableHttpResponse其中包含了响应的各种关键信息如状态码、响应头和响应体等。
response = httpClient.execute(httpPost);
// 将响应体内容通过EntityUtils.toString方法指定编码为"UTF-8"读取出来赋值给resultString变量作为最终的响应结果返回若响应体为空或者读取出现异常等情况会按照相应逻辑处理。
resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
} catch (Exception e) {
throw e;
} finally {
try {
// 关闭响应对象,释放相关资源,确保资源正确回收,避免资源泄漏,无论请求是否成功都需要执行此操作。
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return resultString;
}
/**
* POSTJSONPOSTURLPOSTJSONIO
*
* @param url URLPOSTurl
* @param paramMap MapJSONJSON便JSONPOST
* @return JSONPOSTJSON
* @throws IOException JSONI/O
*/
public static String doPost4Json(String url, Map<String, String> paramMap) throws IOException {
// 创建Httpclient对象获取默认配置的可关闭的HttpClient实例作为发起HTTP的JSON格式POST请求的客户端基础对象。
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
String resultString = "";
try {
// 创建Http Post请求对象使用给定的URL初始化HttpPost实例明确此次请求的方式为POST以及请求的目标地址后续在此基础上构建JSON格式的请求数据。
HttpPost httpPost = new HttpPost(url);
if (paramMap!= null) {
// 构造json格式数据通过遍历请求参数Map将每个参数添加到JSONObject中形成一个JSON格式的对象其中参数名作为JSON对象的属性名参数值作为对应属性的值方便以JSON格式向服务器传递数据符合现在很多基于RESTful API等交互中常用的JSON数据传输规范。
JSONObject jsonObject = new JSONObject();
for (Map.Entry<String, String> param : paramMap.entrySet()) {
jsonObject.put(param.getKey(), param.getValue());
}
// 创建StringEntity对象将JSON对象转换为字符串形式并指定编码为"utf-8",然后设置其内容编码和数据类型(设置为"application/json"表明这是一个JSON格式的数据最后将该请求实体设置到HttpPost请求对象中使得请求携带JSON格式的参数信息。
StringEntity entity = new StringEntity(jsonObject.toString(), "utf-8");
// 设置请求编码,明确请求实体的编码方式为"utf-8",确保数据在传输过程中的编码一致性,便于服务器正确解析接收到的数据。
entity.setContentEncoding("utf-8");
// 设置数据类型,将请求实体的数据类型设置为"application/json"告知服务器此次请求发送的数据是JSON格式的方便服务器按照相应的解析方式处理接收到的数据。
entity.setContentType("application/json");
httpPost.setEntity(entity);
}
// 设置请求配置调用builderRequestConfig方法构建请求配置对象并设置到HttpPost请求中该配置包含了连接超时时间、请求获取连接的超时时间以及套接字超时时间等设置保证请求能在合理的时间范围内完成避免因网络等问题导致请求长时间无响应。
httpPost.setConfig(builderRequestConfig());
// 执行http请求使用HttpClient实例执行HttpPost请求获取服务器返回的响应对象CloseableHttpResponse该对象包含了响应的状态码、响应头以及响应体等重要信息用于后续获取响应结果。
response = httpClient.execute(httpPost);
// 将响应体内容通过EntityUtils.toString方法指定编码为"UTF-8"读取出来赋值给resultString变量作为最终的响应结果返回若响应体为空或者读取出现异常等情况会按照相应逻辑处理。
resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
} catch (Exception e) {
throw e;
} finally {
try {
// 关闭响应对象,释放相关资源,避免资源泄漏,无论请求是否成功都需要执行此操作。
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return resultString;
}
/**
* RequestConfig使TIMEOUT_MSEC5
* HTTPHttpGetHttpPost
*
* @return RequestConfig使
*/
private static RequestConfig builderRequestConfig() {
return RequestConfig.custom()
.setConnectTimeout(TIMEOUT_MSEC)
.setConnectionRequestTimeout(TIMEOUT_MSEC)
.setSocketTimeout(TIMEOUT_MSEC).build();
}
}

@ -0,0 +1,70 @@
package com.sky.utils;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;
/**
* JWT
* <p>
* JWT
*/
public class JwtUtil {
/**
* JWT
* <p>
* 使HS256使
*
* @param secretKey JWT
* @param ttlMillis JWT()
* @param claims
* @return JWT
*/
public static String createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) {
// 指定签名时使用的签名算法即header部分
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
// 生成JWT的时间
long expMillis = System.currentTimeMillis() + ttlMillis;
Date exp = new Date(expMillis);
// 设置jwt的body
JwtBuilder builder = Jwts.builder()
// 如果有私有声明一定要先设置这个自己创建的私有的声明这个是给builder的claim赋值一旦写在标准的声明赋值之后就是覆盖了那些标准的声明的
.setClaims(claims)
// 设置签名使用的签名算法和签名使用的秘钥
.signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))
// 设置过期时间
.setExpiration(exp);
return builder.compact();
}
/**
* Token
* <p>
* JWTClaims
*
* @param secretKey JWTsign
*
* @param token token
* @return Claims
*/
public static Claims parseJWT(String secretKey, String token) {
// 得到DefaultJwtParser
Claims claims = Jwts.parser()
// 设置签名的秘钥
.setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
// 设置需要解析的jwt
.parseClaimsJws(token)
.getBody();
return claims;
}
}

@ -0,0 +1,233 @@
package com.sky.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.sky.properties.WeChatProperties;
import com.wechat.pay.contrib.apache.httpclient.WechatPayHttpClientBuilder;
import com.wechat.pay.contrib.apache.httpclient.util.PemUtil;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.http.HttpHeaders;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.math.BigDecimal;
import java.security.PrivateKey;
import java.security.Signature;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
/**
* 退
*/
@Component
public class WeChatPayUtil {
/**
*
*/
public static final String JSAPI = "https://api.mch.weixin.qq.com/v3/pay/transactions/jsapi";
/**
* 退
*/
public static final String REFUNDS = "https://api.mch.weixin.qq.com/v3/refund/domestic/refunds";
@Autowired
private WeChatProperties weChatProperties;
/**
*
* 使API
*
* @return CloseableHttpClient
*/
private CloseableHttpClient getClient() {
PrivateKey merchantPrivateKey = null;
try {
// 加载商户API私钥
merchantPrivateKey = PemUtil.loadPrivateKey(new FileInputStream(new File(weChatProperties.getPrivateKeyFilePath())));
// 加载微信支付平台证书
X509Certificate x509Certificate = PemUtil.loadCertificate(new FileInputStream(new File(weChatProperties.getWeChatPayCertFilePath())));
List<X509Certificate> wechatPayCertificates = Arrays.asList(x509Certificate);
// 构建HttpClient自动处理签名和验签
WechatPayHttpClientBuilder builder = WechatPayHttpClientBuilder.create()
.withMerchant(weChatProperties.getMchid(), weChatProperties.getMchSerialNo(), merchantPrivateKey)
.withWechatPay(wechatPayCertificates);
CloseableHttpClient httpClient = builder.build();
return httpClient;
} catch (FileNotFoundException e) {
e.printStackTrace();
return null;
}
}
/**
* POSTURL
*
* @param url URL
* @param body JSON
* @return
* @throws Exception
*/
private String post(String url, String body) throws Exception {
CloseableHttpClient httpClient = getClient();
HttpPost httpPost = new HttpPost(url);
httpPost.addHeader(HttpHeaders.ACCEPT, ContentType.APPLICATION_JSON.toString());
httpPost.addHeader(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString());
httpPost.addHeader("Wechatpay-Serial", weChatProperties.getMchSerialNo());
httpPost.setEntity(new StringEntity(body, "UTF-8"));
CloseableHttpResponse response = httpClient.execute(httpPost);
try {
String bodyAsString = EntityUtils.toString(response.getEntity());
return bodyAsString;
} finally {
httpClient.close();
response.close();
}
}
/**
* GETURL
*
* @param url URL
* @return
* @throws Exception
*/
private String get(String url) throws Exception {
CloseableHttpClient httpClient = getClient();
HttpGet httpGet = new HttpGet(url);
httpGet.addHeader(HttpHeaders.ACCEPT, ContentType.APPLICATION_JSON.toString());
httpGet.addHeader(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString());
httpGet.addHeader("Wechatpay-Serial", weChatProperties.getMchSerialNo());
CloseableHttpResponse response = httpClient.execute(httpGet);
try {
String bodyAsString = EntityUtils.toString(response.getEntity());
return bodyAsString;
} finally {
httpClient.close();
response.close();
}
}
/**
* 使JSAPI
*
* @param orderNum
* @param total
* @param description
* @param openid openid
* @return
* @throws Exception
*/
private String jsapi(String orderNum, BigDecimal total, String description, String openid) throws Exception {
JSONObject jsonObject = new JSONObject();
jsonObject.put("appid", weChatProperties.getAppid());
jsonObject.put("mchid", weChatProperties.getMchid());
jsonObject.put("description", description);
jsonObject.put("out_trade_no", orderNum);
jsonObject.put("notify_url", weChatProperties.getNotifyUrl());
JSONObject amount = new JSONObject();
amount.put("total", total.multiply(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP).intValue());
amount.put("currency", "CNY");
jsonObject.put("amount", amount);
JSONObject payer = new JSONObject();
payer.put("openid", openid);
jsonObject.put("payer", payer);
String body = jsonObject.toJSONString();
return post(JSAPI, body);
}
/**
*
*
* @param orderNum
* @param total
* @param description
* @param openid openid
* @return JSONObject
* @throws Exception
*/
public JSONObject pay(String orderNum, BigDecimal total, String description, String openid) throws Exception {
String bodyAsString = jsapi(orderNum, total, description, openid);
JSONObject jsonObject = JSON.parseObject(bodyAsString);
String prepayId = jsonObject.getString("prepay_id");
if (prepayId != null) {
String timeStamp = String.valueOf(System.currentTimeMillis() / 1000);
String nonceStr = RandomStringUtils.randomNumeric(32);
ArrayList<Object> list = new ArrayList<>();
list.add(weChatProperties.getAppid());
list.add(timeStamp);
list.add(nonceStr);
list.add("prepay_id=" + prepayId);
StringBuilder stringBuilder = new StringBuilder();
for (Object o : list) {
stringBuilder.append(o).append("\n");
}
String signMessage = stringBuilder.toString();
byte[] message = signMessage.getBytes();
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initSign(PemUtil.loadPrivateKey(new FileInputStream(new File(weChatProperties.getPrivateKeyFilePath()))));
signature.update(message);
String packageSign = Base64.getEncoder().encodeToString(signature.sign());
JSONObject jo = new JSONObject();
jo.put("timeStamp", timeStamp);
jo.put("nonceStr", nonceStr);
jo.put("package", "prepay_id=" + prepayId);
jo.put("signType", "RSA");
jo.put("paySign", packageSign);
return jo;
}
return jsonObject;
}
/**
* 退
*
* @param outTradeNo
* @param outRefundNo 退
* @param refund 退
* @param total
* @return
* @throws Exception
*/
public String refund(String outTradeNo, String outRefundNo, BigDecimal refund, BigDecimal total) throws Exception {
JSONObject jsonObject = new JSONObject();
jsonObject.put("out_trade_no", outTradeNo);
jsonObject.put("out_refund_no", outRefundNo);
JSONObject amount = new JSONObject();
amount.put("refund", refund.multiply(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP).intValue());
amount.put("total", total.multiply(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP).intValue());
amount.put("currency", "CNY");
jsonObject.put("amount", amount);
jsonObject.put("notify_url", weChatProperties.getRefundNotifyUrl());
String body = jsonObject.toJSONString();
return post(REFUNDS, body);
}
}

@ -0,0 +1,42 @@
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
/**
*
* <p>
* DTO
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
public class CategoryDTO implements Serializable {
/**
* ID
* <p>
*
*/
private Long id;
/**
*
* <p>
* 12
*/
private Integer type;
/**
*
* <p>
*
*/
private String name;
/**
*
* <p>
*
*/
private Integer sort;
}

@ -0,0 +1,41 @@
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
/**
* CategoryPageQueryDTO
* Serializable 便
*/
@Data
public class CategoryPageQueryDTO implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号,用于确保反序列化时的兼容性
/**
*
* 1
*/
private int page;
/**
*
*
*/
private int pageSize;
/**
*
*
*/
private String name;
/**
*
* 1 2
*
*/
private Integer type;
}

@ -0,0 +1,67 @@
package com.sky.dto;
import com.sky.entity.DishFlavor;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
/**
* DishDTOData Transfer Object
* 便
* Serializable
* 使Lombok@DataGetterSettertoStringequalshashCode使
*/
@Data
public class DishDTO implements Serializable {
/**
* id
* 便
*/
private Long id;
/**
*
*
*/
private String name;
/**
* id
* id便
*/
private Long categoryId;
/**
* 使BigDecimal
*
*/
private BigDecimal price;
/**
*
*
*/
private String image;
/**
*
* 便便
*/
private String description;
/**
* 0
* 1便
*/
private Integer status;
/**
* ListDishFlavorDishFlavor
* 便
*/
private List<DishFlavor> flavors = new ArrayList<>();
}

@ -0,0 +1,49 @@
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
public class DishPageQueryDTO implements Serializable {
/**
*
* <p>
* 1
*/
private int page;
/**
*
* <p>
*
*/
private int pageSize;
/**
*
* <p>
*
*/
private String name;
/**
* ID
* <p>
* ID
*/
private Integer categoryId;
/**
*
* <p>
* 01
*/
private Integer status;
}

@ -0,0 +1,33 @@
// 定义包名表示该类属于com.sky.dto包
package com.sky.dto;
// 导入Lombok库中的@Data注解用于自动生成getter和setter方法以及toString、equals和hashCode方法
import lombok.Data;
// 导入Serializable接口使得EmployeeDTO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 使用@Data注解自动为类中的字段生成getter和setter方法
@Data
// 声明EmployeeDTO类并且实现Serializable接口使其可以被序列化
public class EmployeeDTO implements Serializable {
// 定义一个私有的Long类型的变量id用于存储员工的唯一标识符
private Long id;
// 定义一个私有的String类型的变量username用于存储员工的用户名
private String username;
// 定义一个私有的String类型的变量name用于存储员工的姓名
private String name;
// 定义一个私有的String类型的变量phone用于存储员工的电话号码
private String phone;
// 定义一个私有的String类型的变量sex用于存储员工的性别
private String sex;
// 定义一个私有的String类型的变量idNumber用于存储员工的身份证号码
private String idNumber;
}

@ -0,0 +1,33 @@
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
/**
* EmployeePageQueryDTOData Transfer Object
* 便
* Serializable使便使
* 使Lombok@DataGetterSettertoStringequalshashCode便
*/
@Data
public class EmployeePageQueryDTO implements Serializable {
/**
*
* 便
*/
private String name;
/**
*
* 便便
*/
private int page;
/**
*
* 便便
*/
private int pageSize;
}

@ -0,0 +1,35 @@
package com.sky.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
@AllArgsConstructor // 使用lombok提供的注解来自动生成包含所有参数的构造函数
@NoArgsConstructor // 使用lombok提供的注解来自动生成无参数的构造函数
@Builder // 使用lombok提供的注解来自动生成builder模式的构建器
public class GoodsSalesDTO implements Serializable {
/**
*
* <p>
*
*/
private String name;
/**
*
* <p>
*
*/
private Integer number;
}

@ -0,0 +1,22 @@
// 定义包名表示该类属于com.sky.dto包
package com.sky.dto;
// 导入Lombok库中的@Data注解用于自动生成getter和setter方法以及toString、equals和hashCode方法
import lombok.Data;
// 导入Serializable接口使得OrdersCancelDTO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 使用@Data注解自动为类中的字段生成getter和setter方法
@Data
// 声明OrdersCancelDTO类并且实现Serializable接口使其可以被序列化
public class OrdersCancelDTO implements Serializable {
// 定义一个私有的Long类型的变量id用于存储订单的唯一标识符
private Long id;
// 定义一个私有的String类型的变量cancelReason用于存储订单取消的原因
// 订单取消原因
private String cancelReason;
}

@ -0,0 +1,135 @@
package com.sky.dto;
import com.sky.entity.OrderDetail;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
/**
* OrdersDTOData Transfer Object
* 使便使
* Serializable
* 使Lombok@DataGetterSettertoStringequalshashCode使便
*/
@Data
public class OrdersDTO implements Serializable {
/**
* id
* 便
*/
private Long id;
/**
*
* 便
*/
private String number;
/**
*
* 1
* 2
* 3
* 4
* 5退
* 便
*/
private Integer status;
/**
* idid便
*
*/
private Long userId;
/**
*
*
*/
private int tablewareNumber;
/**
*
* 1
* 0便
*/
private Integer tablewareStatus;
/**
* idid
*
*/
private Long addressBookId;
/**
* 使LocalDateTime
*
*/
private LocalDateTime orderTime;
/**
* 使LocalDateTime
*
*/
private LocalDateTime checkoutTime;
/**
*
* 1
* 2使便
*/
private Integer payMethod;
/**
* 使BigDecimal
*
*/
private BigDecimal amount;
/**
*
*
*/
private String remark;
/**
* 便
* 便
*/
private String userName;
/**
*
*
*/
private String phone;
/**
* 便
* id
*/
private String address;
/**
*
*
*/
private String consignee;
/**
* OrderDetailOrderDetail
* 便
*/
private List<OrderDetail> orderDetails;
/**
*
* 1
* 0便
*/
private Integer deliveryStatus;
}

@ -0,0 +1,74 @@
package com.sky.dto;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
public class OrdersPageQueryDTO implements Serializable {
/**
*
* <p>
* 1
*/
private int page;
/**
*
* <p>
*
*/
private int pageSize;
/**
*
* <p>
*
*/
private String number;
/**
*
* <p>
*
*/
private String phone;
/**
*
* <p>
*
*/
private Integer status;
/**
*
* <p>
* yyyy-MM-dd HH:mm:ss
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime beginTime;
/**
*
* <p>
* yyyy-MM-dd HH:mm:ss
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime endTime;
/**
* ID
* <p>
*
*/
private Long userId;
}

@ -0,0 +1,23 @@
// 定义包名表示该类属于com.sky.dto包
package com.sky.dto;
// 导入Lombok库中的@Data注解用于自动生成getter和setter方法以及toString、equals和hashCode方法
import lombok.Data;
// 导入Serializable接口使得OrdersPaymentDTO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 使用@Data注解自动为类中的字段生成getter和setter方法
@Data
// 声明OrdersPaymentDTO类并且实现Serializable接口使其可以被序列化
public class OrdersPaymentDTO implements Serializable {
// 定义一个私有的String类型的变量orderNumber用于存储订单的编号
// 订单号
private String orderNumber;
// 定义一个私有的Integer类型的变量payMethod用于存储订单的付款方式
// 付款方式
private Integer payMethod;
}

@ -0,0 +1,75 @@
package com.sky.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* OrdersSubmitDTOData Transfer Object
* 便
* 使
* Serializable使便使
* 使Lombok@DataGetterSettertoStringequalshashCode便
*/
@Data
public class OrdersSubmitDTO implements Serializable {
/**
* 簿id簿id
* 便
*/
private Long addressBookId;
/**
* 12
* 便
*/
private int payMethod;
/**
*
* 便
*/
private String remark;
/**
* 使LocalDateTime@JsonFormat"yyyy-MM-dd HH:mm:ss"
* 便
*/
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime estimatedDeliveryTime;
/**
*
* 1
* 0便
*/
private Integer deliveryStatus;
/**
*
*
*/
private Integer tablewareNumber;
/**
*
* 1
* 0便
*/
private Integer tablewareStatus;
/**
*
*
*/
private Integer packAmount;
/**
* 使BigDecimal
*
*/
private BigDecimal amount;
}

@ -0,0 +1,35 @@
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
public class PasswordEditDTO implements Serializable {
/**
* ID
* <p>
* ID
*/
private Long empId;
/**
*
* <p>
* 使
*/
private String oldPassword;
/**
*
* <p>
*
*/
private String newPassword;
}

@ -0,0 +1,46 @@
// 定义包名表示该类属于com.sky.dto包
package com.sky.dto;
// 导入com.sky.entity.SetmealDish类这个类可能包含了套餐中包含的菜品信息
import com.sky.entity.SetmealDish;
// 导入Lombok库中的@Data注解用于自动生成getter和setter方法以及toString、equals和hashCode方法
import lombok.Data;
// 导入Serializable接口使得SetmealDTO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 导入BigDecimal类用于精确表示货币等需要高精度的场景
import java.math.BigDecimal;
// 导入ArrayList类用于创建动态数组
import java.util.ArrayList;
// 导入List接口用于定义一个动态数组的引用
import java.util.List;
// 使用@Data注解自动为类中的字段生成getter和setter方法
@Data
// 声明SetmealDTO类并且实现Serializable接口使其可以被序列化
public class SetmealDTO implements Serializable {
// 定义一个私有的Long类型的变量id用于存储套餐的唯一标识符
private Long id;
// 分类id用于标识套餐所属的分类
private Long categoryId;
// 套餐名称,用于存储套餐的名称
private String name;
// 套餐价格使用BigDecimal类型以确保价格的精确表示
private BigDecimal price;
// 状态0表示停用1表示启用
private Integer status;
// 描述信息,用于存储套餐的详细描述
private String description;
// 图片,用于存储套餐的图片链接或路径
private String image;
// 套餐菜品关系用于存储套餐中包含的菜品列表初始为空的ArrayList
private List<SetmealDish> setmealDishes = new ArrayList<>();
}

@ -0,0 +1,33 @@
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
/**
* ShoppingCartDTOData Transfer Object
* 便
* Serializable
* 使Lombok@DataGetterSettertoStringequalshashCode使
*/
@Data
public class ShoppingCartDTO implements Serializable {
/**
* idid
* 便
*/
private Long dishId;
/**
* idid
* id便
*/
private Long setmealId;
/**
*
* 使
*/
private String dishFlavor;
}

@ -0,0 +1,21 @@
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
/**
* C
* <p>
* C
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
public class UserLoginDTO implements Serializable {
/**
*
* <p>
*
*/
private String code;
}

@ -0,0 +1,70 @@
// 定义包名表示该类属于com.sky.entity包
package com.sky.entity;
// 导入Lombok库中的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Serializable接口使得AddressBook类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
/**
* 簿
*/
// 使用@Data注解自动为类中的字段生成getter和setter方法以及toString、equals和hashCode方法
@Data
// 使用@Builder注解提供建造者模式的实现方便对象的构建
@Builder
// 使用@NoArgsConstructor注解生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解生成包含所有属性的构造方法
@AllArgsConstructor
public class AddressBook implements Serializable {
// 定义serialVersionUID用于在序列化和反序列化过程中确保版本一致性
private static final long serialVersionUID = 1L;
// 定义一个私有的Long类型的变量id用于存储地址的唯一标识符
private Long id;
// 用户id用于标识这个地址属于哪个用户
private Long userId;
// 收货人,用于存储收货人的姓名
private String consignee;
// 手机号,用于存储收货人的联系电话
private String phone;
// 性别0表示女性1表示男性
private String sex;
// 省级区划编号,用于标识省份的代码
private String provinceCode;
// 省级名称,用于存储省份的名称
private String provinceName;
// 市级区划编号,用于标识城市的代码
private String cityCode;
// 市级名称,用于存储城市的名称
private String cityName;
// 区级区划编号,用于标识区县的代码
private String districtCode;
// 区级名称,用于存储区县的名称
private String districtName;
// 详细地址,用于存储具体的地址信息
private String detail;
// 标签,用于给地址添加备注或分类
private String label;
// 是否默认0表示否1表示是用于标识这个地址是否是用户的默认地址
private Integer isDefault;
}

@ -0,0 +1,93 @@
package com.sky.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* Dish
* 便使
* Serializable使
* 使LombokGetter/Setter
* @DataGetterSettertoStringequalshashCode
* @Builder便使使
* @NoArgsConstructor@AllArgsConstructor
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Dish implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
* 便
*/
private Long id;
/**
*
* 便
*/
private String name;
/**
* id
* id便
*/
private Long categoryId;
/**
* 使BigDecimal
*
*/
private BigDecimal price;
/**
*
* 广
*/
private String image;
/**
*
* 便便
*/
private String description;
/**
* 0
* 1便
*/
private Integer status;
/**
* 使LocalDateTime
*
*/
private LocalDateTime createTime;
/**
* 使LocalDateTime
* 便
*/
private LocalDateTime updateTime;
/**
* id
* 便
*/
private Long createUser;
/**
* id
*
*/
private Long updateUser;
}

@ -0,0 +1,51 @@
package com.sky.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
@Builder // 提供builder模式的构建器
@NoArgsConstructor // 提供无参数的构造函数
@AllArgsConstructor // 提供包含所有属性的构造函数
public class DishFlavor implements Serializable {
private static final long serialVersionUID = 1L; // 序列化ID用于序列化和反序列化
/**
* ID
* <p>
*
*/
private Long id;
/**
* ID
* <p>
*
*/
private Long dishId;
/**
*
* <p>
*
*/
private String name;
/**
*
* <p>
*
*/
private String value;
}

@ -0,0 +1,71 @@
// 定义包名表示该类属于com.sky.entity包
package com.sky.entity;
// 导入Lombok库中的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Serializable接口使得Employee类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 导入LocalDateTime类用于存储日期和时间
import java.time.LocalDateTime;
/**
*
*/
// 使用@Data注解自动为类中的字段生成getter和setter方法以及toString、equals和hashCode方法
@Data
// 使用@Builder注解提供建造者模式的实现方便对象的构建
@Builder
// 使用@NoArgsConstructor注解生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解生成包含所有属性的构造方法
@AllArgsConstructor
public class Employee implements Serializable {
// 定义serialVersionUID用于在序列化和反序列化过程中确保版本一致性
private static final long serialVersionUID = 1L;
// 定义一个私有的Long类型的变量id用于存储员工的唯一标识符
private Long id;
// 用户名,用于存储员工的登录名
private String username;
// 姓名,用于存储员工的真实姓名
private String name;
// 密码,用于存储员工的登录密码
private String password;
// 手机号,用于存储员工的联系电话
private String phone;
// 性别,通常用"男"或"女"表示
private String sex;
// 身份证号码,用于存储员工的身份证信息
private String idNumber;
// 状态,用于标识员工的当前状态,如在职、离职等
private Integer status;
// 创建时间,用于存储记录创建的时间
// 注释掉的@JsonFormat注解用于在JSON序列化时指定日期时间的格式
// @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createTime;
// 更新时间,用于存储记录最后一次更新的时间
// 注释掉的@JsonFormat注解用于在JSON序列化时指定日期时间的格式
// @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime updateTime;
// 创建用户ID用于标识创建这条记录的用户
private Long createUser;
// 更新用户ID用于标识最后一次更新这条记录的用户
private Long updateUser;
}

@ -0,0 +1,205 @@
package com.sky.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* Orders
*
*
* Serializable使
* 便
* 使LombokGetter/Setter
* @DataGetterSettertoStringequalshashCode
* @Builder便使使
* @NoArgsConstructor@AllArgsConstructor
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Orders implements Serializable {
/**
* 便使
*
* 1
* 2
* 3
* 4
* 5
* 6退
* 7退退退退退
*/
public static final Integer PENDING_PAYMENT = 1;
public static final Integer TO_BE_CONFIRMED = 2;
public static final Integer CONFIRMED = 3;
public static final Integer DELIVERY_IN_PROGRESS = 4;
public static final Integer COMPLETED = 5;
public static final Integer CANCELLED = 6;
/**
* 便
*
* 0
* 1
* 2退退退退
*/
public static final Integer UN_PAID = 0;
public static final Integer PAID = 1;
public static final Integer REFUND = 2;
private static final long serialVersionUID = 1L;
/**
* id
* 便
*/
private Long id;
/**
*
* 便
*/
private String number;
/**
* PENDING_PAYMENTTO_BE_CONFIRMED
* 便
*/
private Integer status;
/**
* idid便
*
*/
private Long userId;
/**
* idid
*
*/
private Long addressBookId;
/**
* 使LocalDateTime
*
*/
private LocalDateTime orderTime;
/**
* 使LocalDateTime
*
*/
private LocalDateTime checkoutTime;
/**
*
* 1
* 2使便
*/
private Integer payMethod;
/**
* UN_PAIDPAIDREFUND
* 退便
*/
private Integer payStatus;
/**
* 使BigDecimal
*
*/
private BigDecimal amount;
/**
*
*
*/
private String remark;
/**
* 便
* 便
*/
private String userName;
/**
*
*
*/
private String phone;
/**
* 便
* id
*/
private String address;
/**
*
*
*/
private String consignee;
/**
*
* 退
*/
private String cancelReason;
/**
*
* 便
*/
private String rejectionReason;
/**
* 使LocalDateTime退
* 线
*/
private LocalDateTime cancelTime;
/**
* 使LocalDateTime
* 便
*/
private LocalDateTime estimatedDeliveryTime;
/**
*
* 1
* 0便
*/
private Integer deliveryStatus;
/**
* 使LocalDateTime
*
*/
private LocalDateTime deliveryTime;
/**
*
*
*/
private int packAmount;
/**
*
*
*/
private int tablewareNumber;
/**
*
* 1
* 0便
*/
private Integer tablewareStatus;
}

@ -0,0 +1,101 @@
package com.sky.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
@Builder // 提供builder模式的构建器
@NoArgsConstructor // 提供无参数的构造函数
@AllArgsConstructor // 提供包含所有属性的构造函数
public class Setmeal implements Serializable {
private static final long serialVersionUID = 1L; // 序列化ID用于序列化和反序列化
/**
* ID
* <p>
*
*/
private Long id;
/**
* ID
* <p>
*
*/
private Long categoryId;
/**
*
* <p>
*
*/
private String name;
/**
*
* <p>
*
*/
private BigDecimal price;
/**
*
* <p>
* 01
*/
private Integer status;
/**
*
* <p>
*
*/
private String description;
/**
*
* <p>
*
*/
private String image;
/**
*
* <p>
*
*/
private LocalDateTime createTime;
/**
*
* <p>
*
*/
private LocalDateTime updateTime;
/**
* ID
* <p>
* ID
*/
private Long createUser;
/**
* ID
* <p>
* ID
*/
private Long updateUser;
}

@ -0,0 +1,48 @@
// 定义包名表示该类属于com.sky.entity包
package com.sky.entity;
// 导入Lombok库中的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Serializable接口使得SetmealDish类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 导入BigDecimal类用于精确表示货币等需要高精度的场景
import java.math.BigDecimal;
/**
*
*/
// 使用@Data注解自动为类中的字段生成getter和setter方法以及toString、equals和hashCode方法
@Data
// 使用@Builder注解提供建造者模式的实现方便对象的构建
@Builder
// 使用@NoArgsConstructor注解生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解生成包含所有属性的构造方法
@AllArgsConstructor
public class SetmealDish implements Serializable {
// 定义serialVersionUID用于在序列化和反序列化过程中确保版本一致性
private static final long serialVersionUID = 1L;
// 定义一个私有的Long类型的变量id用于存储套餐菜品关系的唯一标识符
private Long id;
// 套餐id用于标识套餐的唯一标识符
private Long setmealId;
// 菜品id用于标识菜品的唯一标识符
private Long dishId;
// 菜品名称,冗余字段,用于存储菜品的名称,可能是为了查询方便而存储的额外信息
private String name;
// 菜品原价使用BigDecimal类型以确保价格的精确表示
private BigDecimal price;
// 份数,用于标识套餐中包含的该菜品的份数
private Integer copies;
}

@ -0,0 +1,72 @@
package com.sky.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* User
* openid
*
* Serializable使
*
* 使LombokGetter/Setter
* @DataGetterSettertoStringequalshashCode
* @Builder便使使
* @NoArgsConstructor@AllArgsConstructor
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
* 便
*/
private Long id;
/**
* openid
* openid
*/
private String openid;
/**
* 便使
*/
private String name;
/**
*
*/
private String phone;
/**
* 01
*
*/
private String sex;
/**
*
*/
private String idNumber;
/**
*
*/
private String avatar;
/**
* 使LocalDateTime
*
*/
private LocalDateTime createTime;
}

@ -0,0 +1,56 @@
package com.sky.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
*
* <p>
*
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
@Builder // 提供builder模式的构建器
@NoArgsConstructor // 提供无参数的构造函数
@AllArgsConstructor // 提供包含所有属性的构造函数
public class BusinessDataVO implements Serializable {
/**
*
* <p>
*
*/
private Double turnover;
/**
*
* <p>
*
*/
private Integer validOrderCount;
/**
*
* <p>
*
*/
private Double orderCompletionRate;
/**
*
* <p>
*
*/
private Double unitPrice;
/**
*
* <p>
*
*/
private Integer newUsers;
}

@ -0,0 +1,37 @@
// 定义包名表示该类属于com.sky.vo包
package com.sky.vo;
// 导入Lombok库中的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Serializable接口使得DishItemVO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
/**
*
*/
// 使用@Data注解自动为类中的字段生成getter和setter方法以及toString、equals和hashCode方法
@Data
// 使用@Builder注解提供建造者模式的实现方便对象的构建
@Builder
// 使用@NoArgsConstructor注解生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解生成包含所有属性的构造方法
@AllArgsConstructor
public class DishItemVO implements Serializable {
// 菜品名称,用于存储菜品的名称
private String name;
// 份数,用于标识菜品的份数
private Integer copies;
// 菜品图片,用于存储菜品的图片链接或路径
private String image;
// 菜品描述,用于存储菜品的详细描述信息
private String description;
}

@ -0,0 +1,92 @@
package com.sky.vo;
import com.sky.entity.DishFlavor;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* DishVOValue Object
* 便使
* 使
* Serializable使使
* 使LombokGetter/Setter
* @DataGetterSettertoStringequalshashCode
* @Builder便使
* @NoArgsConstructor@AllArgsConstructor
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DishVO implements Serializable {
/**
* id
* 便
*/
private Long id;
/**
*
* 便
*/
private String name;
/**
* id
* id便
*/
private Long categoryId;
/**
* 使BigDecimal
*
*/
private BigDecimal price;
/**
*
* 广
*/
private String image;
/**
*
* 便便
*/
private String description;
/**
* 0
* 1便
*/
private Integer status;
/**
* 使LocalDateTime
* 便
*/
private LocalDateTime updateTime;
/**
* id便
* id使
*/
private String categoryName;
/**
* ListDishFlavorDishFlavor
* 便
*/
private List<DishFlavor> flavors = new ArrayList<>();
//private Integer copies;
}

@ -0,0 +1,56 @@
package com.sky.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
*
* <p>
* JWT
*/
@Data // 使用lombok提供的注解来自动生成getter和setter方法以及toString等方法
@Builder // 提供builder模式的构建器
@NoArgsConstructor // 提供无参数的构造函数
@AllArgsConstructor // 提供包含所有属性的构造函数
@ApiModel(description = "员工登录返回的数据格式") // Swagger注解用于描述这个VO对象
public class EmployeeLoginVO implements Serializable {
/**
*
* <p>
*
*/
@ApiModelProperty("主键值") // Swagger注解用于描述字段
private Long id;
/**
*
* <p>
*
*/
@ApiModelProperty("用户名") // Swagger注解用于描述字段
private String userName;
/**
*
* <p>
*
*/
@ApiModelProperty("姓名") // Swagger注解用于描述字段
private String name;
/**
* JWT
* <p>
* JWT
*/
@ApiModelProperty("jwt令牌") // Swagger注解用于描述字段
private String token;
}

@ -0,0 +1,40 @@
// 定义包名表示该类属于com.sky.vo包
package com.sky.vo;
// 导入Lombok库中的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Serializable接口使得OrderOverViewVO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
/**
*
*/
// 使用@Data注解自动为类中的字段生成getter和setter方法以及toString、equals和hashCode方法
@Data
// 使用@Builder注解提供建造者模式的实现方便对象的构建
@Builder
// 使用@NoArgsConstructor注解生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解生成包含所有属性的构造方法
@AllArgsConstructor
public class OrderOverViewVO implements Serializable {
// 待接单数量,用于存储待接单的订单数量
private Integer waitingOrders;
// 待派送数量,用于存储待派送的订单数量
private Integer deliveredOrders;
// 已完成数量,用于存储已完成的订单数量
private Integer completedOrders;
// 已取消数量,用于存储已取消的订单数量
private Integer cancelledOrders;
// 全部订单,用于存储总订单数量
private Integer allOrders;
}

@ -0,0 +1,59 @@
package com.sky.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* OrderReportVOValue Object
* 便
* Serializable使使
* 使LombokGetter/Setter
* @DataGetterSettertoStringequalshashCode
* @Builder便使
* @NoArgsConstructor@AllArgsConstructor
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrderReportVO implements Serializable {
/**
* "2022-10-01,2022-10-02,2022-10-03"
* 便
*/
private String dateList;
/**
* "260,210,215"
* List便
*/
private String orderCountList;
/**
* "20,21,10"
*
*/
private String validOrderCountList;
/**
*
* orderCountList
*/
private Integer totalOrderCount;
/**
*
* validOrderCountList
*/
private Integer validOrderCount;
/**
* Double /
* 100便
*/
private Double orderCompletionRate;
}

@ -0,0 +1,32 @@
package com.sky.vo;
import lombok.Data;
import java.io.Serializable;
/**
* OrderStatisticsVO
* Serializable
* 使 Lombok @Data gettersettertoStringequals hashCode
*/
@Data
public class OrderStatisticsVO implements Serializable {
/**
*
*
*/
private Integer toBeConfirmed;
/**
*
*
*/
private Integer confirmed;
/**
*
*
*/
private Integer deliveryInProgress;
}

@ -0,0 +1,41 @@
// 定义包名表示该类属于com.sky.vo包
package com.sky.vo;
// 导入Lombok库中的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Serializable接口使得OrderSubmitVO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 导入BigDecimal类用于精确表示货币等需要高精度的场景
import java.math.BigDecimal;
// 导入LocalDateTime类用于存储日期和时间
import java.time.LocalDateTime;
/**
*
*/
// 使用@Data注解自动为类中的字段生成getter和setter方法以及toString、equals和hashCode方法
@Data
// 使用@Builder注解提供建造者模式的实现方便对象的构建
@Builder
// 使用@NoArgsConstructor注解生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解生成包含所有属性的构造方法
@AllArgsConstructor
public class OrderSubmitVO implements Serializable {
// 订单id用于存储订单的唯一标识符
private Long id;
// 订单号,用于存储订单的编号,通常用于客户和商家之间的交流和查询
private String orderNumber;
// 订单金额使用BigDecimal类型以确保金额的精确表示
private BigDecimal orderAmount;
// 下单时间,用于存储订单被提交的时间
private LocalDateTime orderTime;
}

@ -0,0 +1,35 @@
package com.sky.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* SalesTop10ReportVOValue Object
* 便
* Serializable使使
* 使LombokGetter/Setter
* @DataGetterSettertoStringequalshashCode
* @Builder便使
* @NoArgsConstructor@AllArgsConstructor
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SalesTop10ReportVO implements Serializable {
/**
* "鱼香肉丝,宫保鸡丁,水煮鱼"
* 便
*/
private String nameList;
/**
* "260,215,200"
* 便
*/
private String numberList;
}

@ -0,0 +1,33 @@
package com.sky.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* SetmealOverViewVO
* Serializable
* 使 Lombok @Data@Builder@NoArgsConstructor @AllArgsConstructor
* 访
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SetmealOverViewVO implements Serializable {
/**
*
*
*/
private Integer sold;
/**
*
*
*/
private Integer discontinued;
}

@ -0,0 +1,66 @@
// 定义包名表示该类属于com.sky.vo包
package com.sky.vo;
// 导入com.sky.entity.SetmealDish类这个类可能包含了套餐中包含的菜品信息
import com.sky.entity.SetmealDish;
// 导入Lombok库中的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Serializable接口使得SetmealVO类的对象可以被序列化即可以被转换成字节序列
import java.io.Serializable;
// 导入BigDecimal类用于精确表示货币等需要高精度的场景
import java.math.BigDecimal;
// 导入LocalDateTime类用于存储日期和时间
import java.time.LocalDateTime;
// 导入ArrayList类用于创建动态数组
import java.util.ArrayList;
// 导入List接口用于定义一个动态数组的引用
import java.util.List;
/**
*
*/
// 使用@Data注解自动为类中的字段生成getter和setter方法以及toString、equals和hashCode方法
@Data
// 使用@Builder注解提供建造者模式的实现方便对象的构建
@Builder
// 使用@NoArgsConstructor注解生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解生成包含所有属性的构造方法
@AllArgsConstructor
public class SetmealVO implements Serializable {
// 定义一个私有的Long类型的变量id用于存储套餐的唯一标识符
private Long id;
// 分类id用于标识套餐所属的分类
private Long categoryId;
// 套餐名称,用于存储套餐的名称
private String name;
// 套餐价格使用BigDecimal类型以确保价格的精确表示
private BigDecimal price;
// 状态0表示停用1表示启用
private Integer status;
// 描述信息,用于存储套餐的详细描述
private String description;
// 图片,用于存储套餐的图片链接或路径
private String image;
// 更新时间,用于存储套餐最后一次更新的时间
private LocalDateTime updateTime;
// 分类名称,用于存储套餐所属分类的名称
private String categoryName;
// 套餐和菜品的关联关系初始为空的ArrayList用于存储套餐中包含的菜品列表
private List<SetmealDish> setmealDishes = new ArrayList<>();
}

@ -0,0 +1,41 @@
package com.sky.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* UserLoginVOValue Object
* 便访
* Serializable使使
* 使LombokGetter/Setter
* @DataGetterSettertoStringequalshashCode
* @Builder便使
* @NoArgsConstructor@AllArgsConstructor
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserLoginVO implements Serializable {
/**
* id
* 便
*/
private Long id;
/**
* openid
* openid
*/
private String openid;
/**
* token访
* tokentoken
*/
private String token;
}

@ -0,0 +1,43 @@
package com.sky.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* UserReportVO
* Serializable
* 使 Lombok @Data@Builder@NoArgsConstructor @AllArgsConstructor
*
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserReportVO implements Serializable {
/**
*
* 2022-10-01,2022-10-02,2022-10-03
*
*/
private String dateList;
/**
*
* 200,210,220
* dateList
*/
private String totalUserList;
/**
*
* 20,21,10
* dateList
*/
private String newUserList;
}

@ -0,0 +1,30 @@
package com.sky;
import com.sky.utils.AliOssUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
@SpringBootApplication() // 启用Spring Boot的自动配置和组件扫描
@EnableTransactionManagement // 开启注解方式的事务管理
@Slf4j // 启用Lombok日志功能自动生成log对象
@EnableConfigurationProperties // 允许@ConfigurationProperties注解使用用于从配置文件加载属性
@EnableCaching // 启用Spring的缓存机制
@EnableScheduling // 启用定时任务功能
public class SkyServerApplication {
// 程序的入口点启动Spring Boot应用
public static void main(String[] args) {
SpringApplication.run(SkyServerApplication.class, args); // 启动Spring Boot应用
log.info("server started"); // 输出应用启动的日志信息
}
}

@ -0,0 +1,33 @@
package com.sky.annotation;
import com.sky.enumeration.OperationType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* AutoFill
*
*
* -
* - AOP
*
* 使
*
*
* {@code @AutoFill(OperationType.INSERT)}
*/
@Target(ElementType.METHOD) // 指定该注解只能应用于方法上
@Retention(RetentionPolicy.RUNTIME) // 指定该注解在运行时可用(用于运行时动态处理)
public @interface AutoFill {
/**
*
* {@link OperationType} INSERT UPDATE
*
* @return
*/
OperationType value();
}

@ -0,0 +1,97 @@
// 定义包名表示该类属于com.sky.aspectj包
package com.sky.aspectj;
// 导入所需的类和接口
import com.sky.annotation.AutoFill;
import com.sky.constant.AutoFillConstant;
import com.sky.context.BaseContext;
import com.sky.enumeration.OperationType;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.time.LocalDateTime;
import java.util.*;
// 使用@Aspect注解声明一个切面
@Aspect
// 使用@Slf4j注解为类自动注入一个日志对象
@Slf4j
// 使用@Component注解声明一个Spring组件使其可以被Spring容器管理
@Component
public class AutoFillAspect {
// 定义一个切入点,匹配所有标记了@AutoFill注解的com.sky.mapper包下的方法
@Pointcut("@annotation(com.sky.annotation.AutoFill)" + "&& execution(* com.sky.mapper.*.*(..))")
public void pointCount() {
}
// 前置通知,执行切入点匹配的方法之前
@Before("pointCount()")
public void beforeAutoFillAspect(JoinPoint joinPoint) throws InvocationTargetException, IllegalAccessException {
// 获取方法签名
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
// 获取当前执行的方法
Method method = signature.getMethod();
// 获取方法参数
Object[] args = joinPoint.getArgs();
// 获取方法上的@AutoFill注解
AutoFill autoFill = method.getAnnotation(AutoFill.class);
// 从注解中获取操作类型
OperationType value = autoFill.value();
// 存放每个参数对象及其所有方法的映射
HashMap<Object, Method[]> methodHashMap = new HashMap<>();
// 遍历参数对象,获取每个对象的所有方法
for (Object arg : args) {
Class<?> argClass = arg.getClass();
Method[] methods = argClass.getDeclaredMethods();
methodHashMap.put(arg, methods);
}
// 根据操作类型进行不同的字段填充
if (value.equals(OperationType.INSERT)) {
// 插入操作,填充创建时间和创建用户
for (Map.Entry<Object, Method[]> entry : methodHashMap.entrySet()) {
Object key = entry.getKey();
for (Method method1 : entry.getValue()) {
// 填充创建时间和更新时间
if (method1.getName().equals(AutoFillConstant.SET_UPDATE_TIME) || method.getName().equals(AutoFillConstant.SET_CREATE_TIME)) {
method1.invoke(key, LocalDateTime.now());
}
// 填充创建用户和更新用户
if (method1.getName().equals(AutoFillConstant.SET_CREATE_USER) || method.getName().equals(AutoFillConstant.SET_UPDATE_USER)) {
method1.invoke(key, BaseContext.getCurrentId());
}
}
}
} else if (value.equals(OperationType.UPDATE)) {
// 更新操作,填充更新时间和更新用户
for (Map.Entry<Object, Method[]> entry : methodHashMap.entrySet()) {
Object key = entry.getKey();
for (Method method1 : entry.getValue()) {
// 填充更新时间
if (method1.getName().equals(AutoFillConstant.SET_UPDATE_TIME)) {
method1.invoke(key, LocalDateTime.now());
}
// 填充更新用户
if (method1.getName().equals(AutoFillConstant.SET_UPDATE_USER)) {
method1.invoke(key, BaseContext.getCurrentId());
}
}
}
} else {
// 非法操作类型,抛出异常
throw new IllegalArgumentException("自动填充操作类型参数异常!");
}
}
}

@ -0,0 +1,132 @@
package com.sky.config;
import com.sky.interceptor.JwtTokenAdminInterceptor;
import com.sky.interceptor.JwtTokenUserInterceptor;
import com.sky.json.JacksonObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import java.util.List;
/**
* WebMvcConfigurationweb
* WebMvcConfigurationSupportSpringSpring MVC
* WebWebHTTP
*/
@Configuration
@Slf4j
public class WebMvcConfiguration extends WebMvcConfigurationSupport {
/**
* JwtTokenAdminInterceptor
*
*/
@Autowired
private JwtTokenAdminInterceptor jwtTokenAdminInterceptor;
/**
* JwtTokenUserInterceptor
* 访访
*/
@Autowired
private JwtTokenUserInterceptor jwtTokenUserInterceptor;
/**
* InterceptorRegistry
*
*
* @param registry
*/
protected void addInterceptors(InterceptorRegistry registry) {
log.info("开始注册自定义拦截器...");
// 为管理员拦截器添加拦截路径规则,对以"/admin/"开头的所有路径进行拦截,意味着这些路径下的请求在到达具体的处理方法之前,会先经过这个拦截器进行相关处理。
// 同时排除"/admin/employee/login"路径,即该登录接口不进行拦截,方便管理员进行登录操作,避免登录请求也被拦截导致无法正常登录的情况。
registry.addInterceptor(jwtTokenAdminInterceptor)
.addPathPatterns("/admin/**")
.excludePathPatterns("/admin/employee/login");
// 为用户拦截器添加拦截路径规则,对以"/user/"开头的所有路径进行拦截,使得普通用户相关请求先经过此拦截器验证等操作。
// 排除"/user/user/login"路径,保障普通用户的登录接口能正常访问不受拦截;同时排除"/user/shop/status"路径,该路径对应的功能可能不需要拦截验证等情况,具体根据业务需求而定。
registry.addInterceptor(jwtTokenUserInterceptor)
.addPathPatterns("/user/**")
.excludePathPatterns("/user/user/login")
.excludePathPatterns("/user/shop/status");
}
/**
* knife4jSwagger 2
* Docket
*
* @return Docketknife4j
*/
@Bean
public Docket docket() {
// 创建ApiInfo对象用于设置接口文档的标题、版本以及描述等基本信息这些信息会展示在接口文档页面的头部等位置方便使用者了解接口文档的整体情况。
ApiInfo apiInfo = new ApiInfoBuilder()
.title("接口文档")
.version("2.0")
.description("接口文档")
.build();
// 创建Docket对象指定文档类型为DocumentationType.SWAGGER_2即基于Swagger 2规范来生成文档并设置之前构建好的ApiInfo对象包含了文档的基本描述信息。
// 通过.select()方法开始配置选择哪些接口要生成文档,先指定要扫描的接口所在的基础包路径(这里是"com.sky.controller",意味着该包及其子包下的符合条件的接口会被扫描到),
// 然后通过.paths(PathSelectors.any())表示只要是符合前面包路径下的任何路径对应的接口都会被包含进文档中最后构建出完整的Docket对象。
Docket docket = new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo)
.select()
.apis(RequestHandlerSelectors.basePackage("com.sky.controller"))
.paths(PathSelectors.any())
.build();
return docket;
}
/**
* addResourceHandlers
* 使Web访HTMLJavaScriptCSS
*
* @param registry
*/
@Override
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
// 将请求路径"/doc.html"映射到类路径下的"/META-INF/resources/"目录通常用于将接口文档相关的HTML页面等资源正确映射以便在访问该路径时能展示对应的接口文档页面。
registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
// 将以"/webjars/**"开头的请求路径映射到类路径下的"/META-INF/resources/webjars/"目录,"webjars"一般用于管理Web项目中的前端依赖库等静态资源通过这样的映射确保这些资源能被正确访问和使用。
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
super.addResourceHandlers(registry);
}
/**
* spring MVCSpring MVC
* 使JSONJava
*
* @param converters Spring MVC
*/
protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
log.info("扩展消息转换器....");
// 创建一个MappingJackson2HttpMessageConverter类型的消息转换器对象它是Spring框架中用于处理JSON数据与Java对象转换的常用消息转换器基于Jackson库实现。
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
// 需要为这个消息转化器设置一个对象转换器这里使用自定义的JacksonObjectMapper它继承自ObjectMapper并且配置了一些特定的序列化和反序列化规则
// 比如对日期时间类型等的处理方式通过设置它可以让消息转换器按照项目的特定需求将Java对象准确地序列化为JSON数据以及将接收到的JSON数据反序列化为Java对象。
converter.setObjectMapper(new JacksonObjectMapper());
// 将自己创建并配置好的消息转换器添加到容器中即原有的消息转换器列表里添加到索引为0的位置确保它在处理消息转换时能优先被使用按照自定义的规则进行数据转换操作。
converters.add(0, converter);
}
}

@ -0,0 +1,29 @@
package com.sky.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
/**
* WebSocketConfiguration Spring WebSocket
* @Configuration Spring WebSocket Bean
*/
@Configuration
public class WebSocketConfiguration {
/**
* ServerEndpointExporter Bean Bean WebSocket
*
*
* ServerEndpointExporter Spring WebSocket 使 @ServerEndpoint WebSocket
*
* Spring WebSocket
*
* @return ServerEndpointExporter Bean
*/
@Bean
public ServerEndpointExporter serverEndpointExporter(){
// 返回 ServerEndpointExporter 实例Spring 会自动注册 WebSocket 端点
return new ServerEndpointExporter();
}
}

@ -0,0 +1,134 @@
// 定义包名表示该类属于com.sky.controller.admin包
package com.sky.controller.admin;
// 导入所需的类和接口
import com.sky.dto.CategoryDTO;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.entity.Category;
import com.sky.result.PageResult;
import com.sky.result.Result;
import com.sky.service.CategoryService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
// 使用@RestController注解声明这是一个REST控制器返回的数据会自动转换为JSON格式
@RestController
// 使用@RequestMapping注解定义类级别的路由所有的请求都会以"/admin/category"作为前缀
@RequestMapping("/admin/category")
// 使用@Slf4j注解为类自动注入一个日志对象
@Slf4j
// 使用@Api注解标记这个控制器属于哪个API分类
@Api(tags = "分类相关接口")
public class CategoryController {
// 自动注入CategoryService服务
@Autowired
CategoryService categoryService;
/**
*
*
* @param categoryPageQueryDTO
* @return
*/
@GetMapping({"/page"})
@ApiOperation("分类分页查询")
public Result<PageResult> pageQuery(CategoryPageQueryDTO categoryPageQueryDTO) {
// 记录日志
log.info("分类分页查询:{}", categoryPageQueryDTO);
// 调用服务层进行分页查询
PageResult pageResult = categoryService.pageQuery(categoryPageQueryDTO);
// 返回查询结果
return Result.success(pageResult);
}
/**
*
*
* @param type
* @return
*/
@GetMapping("/list")
@ApiOperation("根据类型查询分类")
public Result<List> query(Integer type) {
// 记录日志
log.info("根据类型查询分类:{}", type);
// 调用服务层根据类型查询分类
List<Category> result = categoryService.query(type);
// 返回查询结果
return Result.success(result);
}
/**
*
*
* @param id ID
* @return
*/
@DeleteMapping
@ApiOperation("删除分类")
public Result deleteCategory(Long id) {
// 记录日志
log.info("删除分类:{}", id);
// 调用服务层删除分类
categoryService.delete(id);
// 返回操作结果
return Result.success();
}
/**
*
*
* @param categoryDTO DTO
* @return
*/
@PutMapping
@ApiOperation("修改分类")
public Result updateCategory(@RequestBody CategoryDTO categoryDTO) {
// 记录日志
log.info("修改分类:{}", categoryDTO);
// 调用服务层修改分类
categoryService.updateCategory(categoryDTO);
// 返回操作结果
return Result.success();
}
/**
*
*
* @param status
* @param id ID
* @return
*/
@PostMapping("/status/{status}")
@ApiOperation("启用禁用分类")
public Result startOrStop(@PathVariable Integer status, Long id) {
// 记录日志
log.info("启用禁用分类status:{},id:{}", status, id);
// 调用服务层启用或禁用分类
categoryService.startOrStop(status, id);
// 返回操作结果
return Result.success();
}
/**
*
*
* @param categoryDTO DTO
* @return
*/
@PostMapping
@ApiOperation("新增分类")
public Result save(@RequestBody CategoryDTO categoryDTO) {
// 记录日志
log.info("新增分类:{}", categoryDTO);
// 调用服务层新增分类
categoryService.save(categoryDTO);
// 返回操作结果
return Result.success();
}
}

@ -0,0 +1,186 @@
package com.sky.controller.admin;
import com.github.pagehelper.Page;
import com.sky.dto.CategoryDTO;
import com.sky.dto.DishDTO;
import com.sky.dto.DishPageQueryDTO;
import com.sky.entity.Dish;
import com.sky.result.PageResult;
import com.sky.result.Result;
import com.sky.service.DishService;
import com.sky.vo.DishVO;
import com.sky.vo.SetmealVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import static jdk.nashorn.internal.runtime.regexp.joni.Config.log;
/**
* DishControllerSpring MVCHTTP
* DishService使RedisTemplate
* 便便
*/
@RestController()
@RequestMapping("/admin/dish")
@Slf4j
@Api("菜品相关接口")
public class DishController {
/**
* DishService
* DishService
*/
@Autowired
DishService dishService;
/**
* RedisTemplateRedis
* RedisTemplate
*/
@Autowired
RedisTemplate redisTemplate;
/**
* DishPageQueryDTO
* DishServicepageQueryPageResult便
*
* @param dishPageQueryDTO
* @return ResultPageResultResultPageResult
*/
@GetMapping("/page")
@ApiOperation("菜品分页查询")
public Result<PageResult> pageQuery(DishPageQueryDTO dishPageQueryDTO) {
log.info("菜品分页查询:{}", dishPageQueryDTO);
PageResult pageResult = dishService.pageQuery(dishPageQueryDTO);
return Result.success(pageResult);
}
/**
* DishDTOJSON@RequestBody
* DishServicesaveWithFlavercleanCache
* Result
*
* @param dishDTO
* @return ResultResult
*/
@PostMapping
@ApiOperation("新增菜品")
public Result save(@RequestBody DishDTO dishDTO) {
log.info("新增菜品:{}", dishDTO);
dishService.saveWithFlaver(dishDTO);
cleanCache("dish_"+dishDTO.getCategoryId());
return Result.success();
}
/**
* idArrayList<Long>@RequestParam使
* idDishServicedeleteBatchcleanCache使"dish_*"
* Result
*
* @param ids id
* @return ResultResult
*/
@DeleteMapping
@ApiOperation("批量删除菜品")
public Result deleteBatch(@RequestParam ArrayList<Long> ids) {
log.info("批量删除菜品:{}", ids);
dishService.deleteBatch(ids);
cleanCache("dish_*");
return Result.success();
}
/**
* idid@PathVariable
* idDishServicegetByIdDishVOResult便
*
* @param id id
* @return ResultDishVOResultDishVO
*/
@GetMapping("/{id}")
public Result<DishVO> getByDishId(@PathVariable Long id) {
log.info("根据id获取菜品:{}", id);
DishVO dish = dishService.getById(id);
return Result.success(dish);
}
/**
* DishDTOJSON@RequestBody
* DishServiceupdateDishcleanCache使"dish_*"
* Result
*
* @param dishDTO
* @return ResultResult
*/
@PutMapping()
@ApiOperation("修改菜品")
public Result updateDish(@RequestBody DishDTO dishDTO) {
log.info("修改菜品:{}", dishDTO);
dishService.updateDish(dishDTO);
cleanCache("dish_*");
return Result.success();
}
/**
* idid
* idDishServicegetByCategoryIdArrayList<Dish>Result
* 便
*
* @param categoryId id
* @return ResultArrayListResultArrayList
*/
@GetMapping("/list")
@ApiOperation("根据分类id查询菜品")
public Result<ArrayList> getByCategoryId(Long categoryId) {
log.info("根据分类id查询菜品");
ArrayList<Dish> dishes = dishService.getByCategoryId(categoryId);
return Result.success(dishes);
}
/**
* id@PathVariableid
* DishServicestartOrStopcleanCache使"dish_*"
* 使@CachePut
* Result
*
* @param id id
* @param status 10
* @return ResultResult
*/
@CachePut
@PostMapping("/status/{status}")
public Result startOrStop(Long id, @PathVariable Integer status) {
log.info("起售停售菜品id:{},status:{}", id, status);
dishService.startOrStop(id, status);
cleanCache("dish_*");
return Result.success();
}
/**
* RedisRedisTemplatekeys使"dish_*""dish_"
* 使RedisTemplatedelete
*
* @param pattern 使
*/
private void cleanCache(String pattern) {
Set keys = redisTemplate.keys(pattern);
redisTemplate.delete(keys);
}
}

@ -0,0 +1,166 @@
package com.sky.controller.admin;
import com.sky.constant.JwtClaimsConstant;
import com.sky.context.BaseContext;
import com.sky.dto.EmployeeDTO;
import com.sky.dto.EmployeeLoginDTO;
import com.sky.dto.EmployeePageQueryDTO;
import com.sky.entity.Employee;
import com.sky.properties.JwtProperties;
import com.sky.result.PageResult;
import com.sky.result.Result;
import com.sky.service.EmployeeService;
import com.sky.utils.JwtUtil;
import com.sky.vo.EmployeeLoginVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
/**
*
*
* 使 Swagger API
*/
@RestController
@RequestMapping("/admin/employee")
@Slf4j
@Api(tags = "员工相关接口")
public class EmployeeController {
@Autowired
private EmployeeService employeeService; // 注入员工服务类,用于处理员工相关业务
@Autowired
private JwtProperties jwtProperties; // 注入 JWT 配置类,用于生成 JWT 令牌
/**
*
* JWT
*
* @param employeeLoginDTO
* @return JWT
*/
@PostMapping("/login")
@ApiOperation(value = "员工登录")
public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) {
log.info("员工登录:{}", employeeLoginDTO); // 记录登录请求日志
// 调用员工服务进行登录验证
Employee employee = employeeService.login(employeeLoginDTO);
// 登录成功后,生成 JWT 令牌
Map<String, Object> claims = new HashMap<>();
claims.put(JwtClaimsConstant.EMP_ID, employee.getId()); // 将员工ID放入JWT的claims部分
String token = JwtUtil.createJWT(
jwtProperties.getAdminSecretKey(), // 获取密钥
jwtProperties.getAdminTtl(), // 获取有效期
claims); // 设置 JWT claims
// 将登录者的 ID 设置到当前线程上下文中,以便其他地方使用
BaseContext.setCurrentId(employee.getId());
// 构造员工登录响应对象
EmployeeLoginVO employeeLoginVO = EmployeeLoginVO.builder()
.id(employee.getId())
.userName(employee.getUsername())
.name(employee.getName())
.token(token)
.build();
return Result.success(employeeLoginVO); // 返回成功结果
}
/**
* 退
* 退退
*
* @return 退
*/
@PostMapping("/logout")
@ApiOperation("员工退出")
public Result<String> logout() {
return Result.success(); // 直接返回成功
}
/**
*
*
*
* @param employeeDTO
* @return
*/
@PostMapping
@ApiOperation("新增员工")
public Result save(@RequestBody EmployeeDTO employeeDTO) {
log.info("新增员工:{}", employeeDTO); // 记录新增员工请求日志
employeeService.save(employeeDTO); // 调用服务层保存员工数据
return Result.success(); // 返回成功结果
}
/**
*
*
*
* @param employeePageQueryDTO
* @return
*/
@GetMapping("/page")
@ApiOperation("员工分页查询")
public Result<PageResult> pageQuery(EmployeePageQueryDTO employeePageQueryDTO){
log.info("员工分页查询,参数为:{}", employeePageQueryDTO); // 记录分页查询请求日志
PageResult pageResult = employeeService.pageQuery(employeePageQueryDTO); // 调用服务层进行分页查询
return Result.success(pageResult); // 返回分页查询结果
}
/**
*
*
*
* @param status 10
* @param id ID
* @return
*/
@PostMapping("/status/{status}")
@ApiOperation("启用或禁用员工账号")
public Result startOrStop(@PathVariable Integer status, Long id) {
log.info("启用禁用员工账号{},{}", status, id); // 记录启用禁用请求日志
employeeService.startOrStop(status, id); // 调用服务层启用或禁用员工账号
return Result.success(); // 返回成功结果
}
/**
* ID
*
*
* @param id ID
* @return
*/
@GetMapping("/{id}")
@ApiOperation("通过id查询员工信息")
public Result<Employee> getById(@PathVariable Long id) {
Employee employee = employeeService.getById(id); // 调用服务层查询员工
return Result.success(employee); // 返回查询结果
}
/**
*
*
*
* @param employeeDTO
* @return
*/
@PutMapping
@ApiOperation("编辑员工信息")
public Result update(@RequestBody EmployeeDTO employeeDTO) {
log.info("编辑员工信息:{}", employeeDTO); // 记录编辑员工信息请求日志
employeeService.update(employeeDTO); // 调用服务层更新员工信息
return Result.success(); // 返回成功结果
}
}

@ -0,0 +1,153 @@
// 定义包名表示该类属于com.sky.controller.admin包
package com.sky.controller.admin;
// 导入所需的类和接口
import com.sky.dto.OrdersCancelDTO;
import com.sky.dto.OrdersConfirmDTO;
import com.sky.dto.OrdersPageQueryDTO;
import com.sky.dto.OrdersRejectionDTO;
import com.sky.result.PageResult;
import com.sky.result.Result;
import com.sky.service.OrderService;
import com.sky.vo.OrderStatisticsVO;
import com.sky.vo.OrderVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
*
*/
@RestController("adminOrderController")
@RequestMapping("/admin/order")
@Slf4j
@Api(tags = "订单管理接口")
public class OrderController {
// 自动注入OrderService服务
@Autowired
private OrderService orderService;
/**
*
*
* @param id ID
* @return
*/
@PutMapping("/complete/{id}")
@ApiOperation("完成订单")
public Result complete(@PathVariable("id") Long id) {
// 调用服务层完成订单
orderService.complete(id);
// 返回操作结果
return Result.success();
}
/**
*
*
* @param id ID
* @return
*/
@PutMapping("/delivery/{id}")
@ApiOperation("派送订单")
public Result delivery(@PathVariable("id") Long id) {
// 调用服务层派送订单
orderService.delivery(id);
// 返回操作结果
return Result.success();
}
/**
*
*
* @param ordersPageQueryDTO
* @return
*/
@GetMapping("/conditionSearch")
@ApiOperation("订单搜索")
public Result<PageResult> conditionSearch(OrdersPageQueryDTO ordersPageQueryDTO) {
// 调用服务层进行订单搜索
PageResult pageResult = orderService.conditionSearch(ordersPageQueryDTO);
// 返回搜索结果
return Result.success(pageResult);
}
/**
*
*
* @return
*/
@GetMapping("/statistics")
@ApiOperation("各个状态的订单数量统计")
public Result<OrderStatisticsVO> statistics() {
// 调用服务层获取订单数量统计
OrderStatisticsVO orderStatisticsVO = orderService.statistics();
// 返回统计结果
return Result.success(orderStatisticsVO);
}
/**
*
*
* @param id ID
* @return
*/
@GetMapping("/details/{id}")
@ApiOperation("查询订单详情")
public Result<OrderVO> details(@PathVariable("id") Long id) {
// 调用服务层查询订单详情
OrderVO orderVO = orderService.details(id);
// 返回订单详情
return Result.success(orderVO);
}
/**
*
*
* @param ordersConfirmDTO
* @return
*/
@PutMapping("/confirm")
@ApiOperation("接单")
public Result confirm(@RequestBody OrdersConfirmDTO ordersConfirmDTO) {
// 调用服务层接单
orderService.confirm(ordersConfirmDTO);
// 返回操作结果
return Result.success();
}
/**
*
*
* @param ordersRejectionDTO
* @return
* @throws Exception
*/
@PutMapping("/rejection")
@ApiOperation("拒单")
public Result rejection(@RequestBody OrdersRejectionDTO ordersRejectionDTO) throws Exception {
// 调用服务层拒单
orderService.rejection(ordersRejectionDTO);
// 返回操作结果
return Result.success();
}
/**
*
*
* @param ordersCancelDTO
* @return
* @throws Exception
*/
@PutMapping("/cancel")
@ApiOperation("取消订单")
public Result cancel(@RequestBody OrdersCancelDTO ordersCancelDTO) throws Exception {
// 调用服务层取消订单
orderService.cancel(ordersCancelDTO);
// 返回操作结果
return Result.success();
}
}

@ -0,0 +1,149 @@
package com.sky.controller.admin;
import com.sky.dto.CategoryDTO;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.dto.SetmealDTO;
import com.sky.dto.SetmealPageQueryDTO;
import com.sky.entity.Category;
import com.sky.result.PageResult;
import com.sky.result.Result;
import com.sky.service.CategoryService;
import com.sky.service.SetmealService;
import com.sky.vo.SetmealVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Delete;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
/**
* SetmealControllerSpring MVCHTTP
* SetmealServiceid
* Spring@CacheEvict便
*/
@RestController
@Api("套餐相关接口")
@Slf4j
@RequestMapping("/admin/setmeal")
public class SetmealController {
/**
* SetmealServiceSetmealService
*
*/
@Autowired
SetmealService setmealService;
/**
* SetmealPageQueryDTO
* SetmealServicepageQuery
* PageResultResult便
*
* @param setmealPageQueryDTO 便
* @return ResultPageResultResultPageResult
*/
@GetMapping("/page")
@ApiOperation("分页查询套餐")
public Result<PageResult> pageQuery(SetmealPageQueryDTO setmealPageQueryDTO) {
log.info("分页查询套餐:{}", setmealPageQueryDTO);
PageResult result = setmealService.pageQuery(setmealPageQueryDTO);
return Result.success(result);
}
/**
* @PathVariable10
* idSetmealServicestartOrStop
* 使@CacheEvict"setmealCache"allEntriestrue
* Result
*
* @param status 便
* @param id id
* @return ResultResult
*/
@PostMapping("/status/{status}")
@ApiOperation("起售停售套餐")
@CacheEvict(cacheNames = "setmealCache", allEntries = true)
public Result startOrStop(@PathVariable Integer status, Long id) {
log.info("{}套餐id={}", status == 1? "起售" : "停售", id);
setmealService.startOrStop(status, id);
return Result.success();
}
/**
* SetmealDTOJSON@RequestBody
* SetmealServiceupdateSetmeal使@CacheEvict"setmealCache"allEntriestrue
* Result
*
* @param setmealDTO
* @return ResultResult
*/
@PutMapping
@ApiOperation("修改套餐信息")
@CacheEvict(cacheNames = "setmealCache", allEntries = true)
public Result updateSetmeal(@RequestBody SetmealDTO setmealDTO) {
log.info("修改套餐信息:{}", setmealDTO);
setmealService.updateSetmeal(setmealDTO);
return Result.success();
}
/**
* idid@PathVariable
* idSetmealServicegetDishByIdSetmealVO
* Result便
*
* @param id id
* @return ResultSetmealVOResultSetmealVO
*/
@GetMapping("/{id}")
@ApiOperation("根据id查询套餐")
public Result<SetmealVO> getDishById(@PathVariable Long id) {
log.info("根据套餐id查询套餐");
SetmealVO setmealVO = setmealService.getDishById(id);
return Result.success(setmealVO);
}
/**
* ididArrayList<Long>@RequestParam使
* idSetmealServicebatchDeleteById使@CacheEvict"setmealCache"allEntriestrue
* Result
*
* @param ids id
* @return ResultResult
*/
@DeleteMapping
@ApiOperation("根据id批量删除套餐")
@CacheEvict(cacheNames = "setmealCache", allEntries = true)
public Result batchDeleteById(@RequestParam ArrayList<Long> ids) {
log.info("根据id批量删除套餐:{}", ids);
setmealService.batchDeleteById(ids);
return Result.success();
}
/**
* SetmealDTOJSON@RequestBody
* SetmealServiceinsert使@CacheEvictSetmealDTOcategoryId
* Result
*
* @param setmealDTO categoryId
* @return ResultResult
*/
@CacheEvict(cacheNames = "setmealCache", key = "#setmealDTO.categoryId")
@PostMapping
@ApiOperation("新增套餐")
public Result insert(@RequestBody SetmealDTO setmealDTO) {
log.info("新增套餐:{}", setmealDTO);
setmealService.insert(setmealDTO);
return Result.success();
}
}

@ -0,0 +1,67 @@
package com.sky.controller.admin;
import com.sky.result.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.*;
/**
*
*
* 使 Redis 便
*/
@RestController("adminShopController")
@Slf4j
@Api("管理员店铺相关接口")
@RequestMapping("/admin/shop")
public class ShopController {
@Autowired
private RedisTemplate redisTemplate; // 注入 RedisTemplate 用于操作 Redis 数据库
private static final String key = "SHOP_STATUS"; // 定义 Redis 中保存店铺状态的键
/**
*
* 1 0
*
* @param status 1: , 0:
* @return
*/
@PutMapping("/{status}")
@ApiOperation("设置店铺营业状态")
public Result setStatus(@PathVariable Integer status) {
// 记录设置店铺状态的日志信息
log.info("设置店铺营业状态为:{}", status == 1 ? "营业中" : "打烊中");
// 获取 Redis 的 ValueOperations 操作对象
ValueOperations valueOperations = redisTemplate.opsForValue();
// 将店铺状态保存到 Redis 中
valueOperations.set(key, status);
return Result.success(); // 返回成功结果
}
/**
*
* 1 0
*
* @return
*/
@GetMapping("/status")
@ApiOperation("查询店铺营业状态")
public Result<Integer> queryStatus() {
// 获取 Redis 的 ValueOperations 操作对象
ValueOperations valueOperations = redisTemplate.opsForValue();
// 从 Redis 中获取店铺状态
Integer status = (Integer) valueOperations.get(key);
// 记录查询店铺状态的日志信息
log.info("店铺状态为:{}", status == 1 ? "营业中" : "打烊中");
return Result.success(status); // 返回查询结果
}
}

@ -0,0 +1,94 @@
// 定义包名表示该类属于com.sky.controller.admin包
package com.sky.controller.admin;
// 导入所需的类和接口
import com.sky.result.Result;
import com.sky.service.WorkspaceService;
import com.sky.vo.BusinessDataVO;
import com.sky.vo.DishOverViewVO;
import com.sky.vo.OrderOverViewVO;
import com.sky.vo.SetmealOverViewVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.time.LocalTime;
/**
*
*/
@RestController
@RequestMapping("/admin/workspace")
@Slf4j
@Api(tags = "工作台相关接口")
public class WorkSpaceController {
// 自动注入WorkspaceService服务
@Autowired
private WorkspaceService workspaceService;
/**
*
*
* @return
*/
@GetMapping("/businessData")
@ApiOperation("工作台今日数据查询")
public Result<BusinessDataVO> businessData(){
// 获得当天的开始时间00:00:00
LocalDateTime begin = LocalDateTime.now().with(LocalTime.MIN);
// 获得当天的结束时间23:59:59
LocalDateTime end = LocalDateTime.now().with(LocalTime.MAX);
// 调用服务层获取工作台今日数据
BusinessDataVO businessDataVO = workspaceService.getBusinessData(begin, end);
// 返回工作台今日数据
return Result.success(businessDataVO);
}
/**
*
*
* @return
*/
@GetMapping("/overviewOrders")
@ApiOperation("查询订单管理数据")
public Result<OrderOverViewVO> orderOverView(){
// 调用服务层获取订单管理数据
OrderOverViewVO orderOverViewVO = workspaceService.getOrderOverView();
// 返回订单管理数据
return Result.success(orderOverViewVO);
}
/**
*
*
* @return
*/
@GetMapping("/overviewDishes")
@ApiOperation("查询菜品总览")
public Result<DishOverViewVO> dishOverView(){
// 调用服务层获取菜品总览数据
DishOverViewVO dishOverViewVO = workspaceService.getDishOverView();
// 返回菜品总览数据
return Result.success(dishOverViewVO);
}
/**
*
*
* @return
*/
@GetMapping("/overviewSetmeals")
@ApiOperation("查询套餐总览")
public Result<SetmealOverViewVO> setmealOverView(){
// 调用服务层获取套餐总览数据
SetmealOverViewVO setmealOverViewVO = workspaceService.getSetmealOverView();
// 返回套餐总览数据
return Result.success(setmealOverViewVO);
}
}

@ -0,0 +1,149 @@
package com.sky.controller.user;
import com.sky.context.BaseContext;
import com.sky.entity.AddressBook;
import com.sky.result.Result;
import com.sky.service.AddressBookService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* AddressBookControllerSpring MVCC簿HTTP
* AddressBookServiceid//
* 便簿便使
*/
@RestController
@RequestMapping("/user/addressBook")
@Api(tags = "C端地址簿接口")
@Slf4j
public class AddressBookController {
/**
* AddressBookServiceAddressBookService簿
* 簿
*/
@Autowired
private AddressBookService addressBookService;
/**
* AddressBook
* BaseContext.getCurrentId()BaseContextididAddressBook
* AddressBookServicelistList<AddressBook>Result
* 便
*
* @return ResultList<AddressBook>ResultList<AddressBook>
*/
@GetMapping("/list")
@ApiOperation("查询当前登录用户的所有地址信息")
public Result<List<AddressBook>> list() {
log.info("查询当前登录用户的所有地址信息");
AddressBook addressBook = new AddressBook();
addressBook.setUserId(BaseContext.getCurrentId());
List<AddressBook> list = addressBookService.list(addressBook);
return Result.success(list);
}
/**
* AddressBookJSON@RequestBody
* AddressBookServicesaveResult便
*
* @param addressBook
* @return ResultResult
*/
@PostMapping
@ApiOperation("新增地址")
public Result save(@RequestBody AddressBook addressBook) {
log.info("新增地址:{}", addressBook);
addressBookService.save(addressBook);
return Result.success();
}
/**
* idid@PathVariable
* idAddressBookServicegetByIdAddressBook
* Result便使
*
* @param id id
* @return ResultAddressBookResultAddressBook
*/
@GetMapping("/{id}")
@ApiOperation("根据id查询地址")
public Result<AddressBook> getById(@PathVariable Long id) {
log.info("根据id查询地址,id:{}", id);
AddressBook addressBook = addressBookService.getById(id);
return Result.success(addressBook);
}
/**
* idAddressBookJSON@RequestBody
* AddressBookServiceupdateResult便
*
* @param addressBook
* @return ResultResult
*/
@PutMapping
@ApiOperation("根据id修改地址")
public Result update(@RequestBody AddressBook addressBook) {
log.info("根据id修改地址:{}", addressBook);
addressBookService.update(addressBook);
return Result.success();
}
/**
* AddressBookJSON@RequestBody
* AddressBookServicesetDefaultAddressBookService
* Result便便使
*
* @param addressBook id
* @return ResultResult
*/
@PutMapping("/default")
@ApiOperation("设置默认地址")
public Result setDefault(@RequestBody AddressBook addressBook) {
log.info("设置默认地址:{}", addressBook);
addressBookService.setDefault(addressBook);
return Result.success();
}
/**
* idid
* idAddressBookServicedeleteByIdResult便
*
* @param id id
* @return ResultidResult
*/
@DeleteMapping
@ApiOperation("根据id删除地址")
public Result deleteById(Long id) {
log.info("根据id删除地址,id:{}", id);
addressBookService.deleteById(id);
return Result.success();
}
/**
* AddressBookisDefault1BaseContext.getCurrentId()idAddressBook
* AddressBookServicelistResult
* Result便使
*/
@GetMapping("default")
@ApiOperation("查询默认地址")
public Result<AddressBook> getDefault() {
log.info("查询默认地址");
// SQL:select * from address_book where user_id =? and is_default = 1
AddressBook addressBook = new AddressBook();
addressBook.setIsDefault(1);
addressBook.setUserId(BaseContext.getCurrentId());
List<AddressBook> list = addressBookService.list(addressBook);
if (list!= null && list.size() == 1) {
return Result.success(list.get(0));
}
return Result.error("没有查询到默认地址");
}
}

@ -0,0 +1,48 @@
package com.sky.controller.user;
import com.sky.entity.Category;
import com.sky.result.Result;
import com.sky.service.CategoryService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* -
*
*/
@RestController("userCategoryController")
@RequestMapping("/user/category")
@Api(tags = "C端-分类接口")
@Slf4j
public class CategoryController {
@Autowired
private CategoryService categoryService; // 注入 CategoryService 服务,用于查询分类信息
/**
*
* type
*
* @param type
* @return
*/
@GetMapping("/list")
@ApiOperation("查询分类")
public Result<List<Category>> list(Integer type) {
// 记录查询分类操作的日志,输出传入的分类类型参数
log.info("查询分类{}", type);
// 调用 categoryService 查询分类信息
List<Category> list = categoryService.query(type);
// 返回查询结果,封装在 Result 对象中
return Result.success(list);
}
}

@ -0,0 +1,75 @@
// 定义包名表示该类属于com.sky.controller.user包
package com.sky.controller.user;
// 导入所需的类和接口
import com.sky.constant.StatusConstant;
import com.sky.entity.Dish;
import com.sky.result.Result;
import com.sky.service.DishService;
import com.sky.vo.DishVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
// 使用@RestController注解声明这是一个REST控制器返回的数据会自动转换为JSON格式
@RestController("userDishController")
// 使用@RequestMapping注解定义类级别的路由所有的请求都会以"/user/dish"作为前缀
@RequestMapping("/user/dish")
// 使用@Slf4j注解为类自动注入一个日志对象
@Slf4j
// 使用@Api注解标记这个控制器属于哪个API分类
@Api(tags = "C端-菜品浏览接口")
public class DishController {
// 自动注入DishService服务
@Autowired
private DishService dishService;
// 自动注入RedisTemplate用于操作Redis缓存
@Autowired
private RedisTemplate redisTemplate;
/**
* id
*
* @param categoryId ID
* @return
*/
@GetMapping("/list")
@ApiOperation("根据分类id查询菜品")
public Result<List<DishVO>> list(Long categoryId) {
// 记录日志输出查询的分类ID
log.info("根据分类id查询菜品:{}", categoryId);
// 定义Redis缓存的键
String key = "dish_" + categoryId;
// 从缓存中获取菜品列表
ValueOperations valueOperations = redisTemplate.opsForValue();
List<DishVO> dishVOList = (List<DishVO>) valueOperations.get(key);
// 如果缓存中存在菜品列表,直接返回
if (dishVOList != null && dishVOList.size() > 0) {
return Result.success(dishVOList);
}
// 如果缓存中不存在,则从数据库中查询
Dish dish = new Dish();
dish.setCategoryId(categoryId); // 设置查询条件为分类ID
dish.setStatus(StatusConstant.ENABLE); // 查询起售中的菜品
// 从数据库中获取菜品列表,并存入缓存
List<DishVO> list = dishService.listWithFlavor(dish);
valueOperations.set(key, list); // 将查询结果存入Redis缓存
// 返回查询结果
return Result.success(list);
}
}

@ -0,0 +1,81 @@
package com.sky.controller.user;
import com.sky.constant.StatusConstant;
import com.sky.entity.Setmeal;
import com.sky.result.Result;
import com.sky.service.SetmealService;
import com.sky.vo.DishItemVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* SetmealControllerSpring MVCCHTTP
* SetmealServiceidid
* Spring@Cacheable便便
*/
@RestController("userSetmealController")
@RequestMapping("/user/setmeal")
@Api(tags = "C端-套餐浏览接口")
@Slf4j
public class SetmealController {
/**
* SetmealServiceSetmealService
*
*/
@Autowired
private SetmealService setmealService;
/**
* idid
* SetmealidStatusConstant.ENABLE
* SetmealSetmealServicelistList<Setmeal>Result
* 便
* 使@Cacheable"setmealCache"idid
*
* @param categoryId id便
* @return ResultList<Setmeal>ResultList<Setmeal>
*/
@GetMapping("/list")
@ApiOperation("根据分类id查询起售套餐")
@Cacheable(cacheNames = "setmealCache", key = "#categoryId")
public Result<List<Setmeal>> list(Long categoryId) {
log.info("根据分类id查询起售套餐:{}", categoryId);
Setmeal setmeal = new Setmeal();
setmeal.setCategoryId(categoryId);
setmeal.setStatus(StatusConstant.ENABLE);
List<Setmeal> list = setmealService.list(setmeal);
return Result.success(list);
}
/**
* idid@PathVariable"id"
* idSetmealServicegetDishItemByIdList<DishItemVO>
* Result便使
*
* @param id id
* @return ResultList<DishItemVO>ResultList<DishItemVO>
*/
@GetMapping("/dish/{id}")
@ApiOperation("根据套餐id查询包含的菜品列表")
public Result<List<DishItemVO>> dishList(@PathVariable("id") Long id) {
log.info("根据套餐id查询包含的菜品列表{}", id);
List<DishItemVO> list = setmealService.getDishItemById(id);
return Result.success(list);
}
}

@ -0,0 +1,48 @@
package com.sky.controller.user;
import com.sky.result.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.*;
/**
* -
*
* 使 Redis 便
*/
@RestController("userShopController")
@Slf4j
@Api("用户店铺相关接口")
@RequestMapping("/user/shop")
public class ShopController {
@Autowired
private RedisTemplate redisTemplate; // 注入 RedisTemplate 用于操作 Redis 数据库
private static final String key = "SHOP_STATUS"; // 定义 Redis 中保存店铺状态的键
/**
*
* 1 0
*
* @return
*/
@GetMapping("/status")
@ApiOperation("查询店铺营业状态")
public Result<Integer> queryStatus() {
// 获取 Redis 的 ValueOperations 操作对象
ValueOperations valueOperations = redisTemplate.opsForValue();
// 从 Redis 中获取店铺状态
Integer status = (Integer) valueOperations.get(key);
// 记录查询店铺状态的日志信息
log.info("店铺状态为:{}", status == 1 ? "营业中" : "打烊中");
// 返回查询结果,封装在 Result 对象中
return Result.success(status);
}
}

@ -0,0 +1,99 @@
// 定义包名表示该类属于com.sky.controller.user包
package com.sky.controller.user;
// 导入所需的类和接口
import com.sky.dto.ShoppingCartDTO;
import com.sky.entity.ShoppingCart;
import com.sky.result.Result;
import com.sky.service.ShoppingCartService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
// 使用@RestController注解声明这是一个REST控制器返回的数据会自动转换为JSON格式
@RestController
// 使用@Api注解标记这个控制器属于哪个API分类
@Api("C端购物车相关接口")
// 使用@Slf4j注解为类自动注入一个日志对象
@Slf4j
// 使用@RequestMapping注解定义类级别的路由所有的请求都会以"/user/shoppingCart"作为前缀
@RequestMapping("/user/shoppingCart")
public class ShoppingCartController {
// 自动注入ShoppingCartService服务
@Autowired
ShoppingCartService shoppingCartService;
/**
*
*
* @param shoppingCartDTO DTO
* @return
*/
@PostMapping("/add")
@ApiOperation("添加购物车")
public Result add(@RequestBody ShoppingCartDTO shoppingCartDTO) {
// 记录日志,输出添加到购物车的商品信息
log.info("添加购物车:购物车信息:{}", shoppingCartDTO);
// 调用服务层添加商品到购物车
shoppingCartService.add(shoppingCartDTO);
// 返回操作成功的结果
return Result.success();
}
/**
*
*
* @return
*/
@GetMapping("/list")
@ApiOperation("查看购物车")
public Result<List<ShoppingCart>> list() {
// 记录日志,标记查看购物车数据的操作
log.info("查看购物车数据");
// 调用服务层获取用户购物车中的商品列表
List<ShoppingCart> shoppingCartList = shoppingCartService.list();
// 返回购物车商品列表
return Result.success(shoppingCartList);
}
/**
*
*
* @param shoppingCartDTO DTO
* @return
*/
@PostMapping("/sub")
@ApiOperation("删除购物车中的商品")
public Result delete(@RequestBody ShoppingCartDTO shoppingCartDTO){
// 记录日志,输出删除的商品信息
log.info("删除购物车中的商品:{}",shoppingCartDTO);
// 调用服务层删除购物车中的一个商品
shoppingCartService.delete(shoppingCartDTO);
// 返回操作成功的结果
return Result.success();
}
/**
*
*
* @return
*/
@DeleteMapping("/clean")
@ApiOperation("清空购物车")
public Result clean(){
// 记录日志,标记清空购物车的操作
log.info("清空购物车");
// 调用服务层清空购物车
shoppingCartService.clean();
// 返回操作成功的结果
return Result.success();
}
}

@ -0,0 +1,61 @@
package com.sky.handler;
import com.sky.constant.MessageConstant;
import com.sky.exception.BaseException;
import com.sky.result.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import java.sql.SQLIntegrityConstraintViolationException;
/**
* GlobalExceptionHandler
* 使Spring@RestControllerAdvice使@RestController
*
*/
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
/**
* 使@ExceptionHandlerBaseException
* BaseException
* ResultResult.errorResult
* 使
*
* @param ex BaseException
* @return Result便
*/
@ExceptionHandler(BaseException.class)
public Result exceptionHandler(BaseException ex) {
log.error("异常信息:{}", ex.getMessage());
return Result.error(ex.getMessage());
}
/**
* SQL使@ExceptionHandlerSQLIntegrityConstraintViolationException
* SQLIntegrityConstraintViolationException
*
* "Duplicate entry"
* MessageConstant.ALREADY_EXISTS
* MessageConstant.UNKNOWN_ERRORResultMessageConstant.ALREADY_EXISTS
*
*
* @param exception SQLIntegrityConstraintViolationException
* @return ResultSQL便
*/
@ExceptionHandler
public Result SQLExceptionHandler(SQLIntegrityConstraintViolationException exception) {
System.out.println(exception);
String msg = exception.getMessage();
String[] split = msg.split(" ");
if (msg.contains("Duplicate entry")) {
String name = split[2];
log.error("异常信息:{}", name + MessageConstant.ALREADY_EXISTS);
} else {
log.error("异常信息:{}", MessageConstant.UNKNOWN_ERROR);
}
return Result.error(MessageConstant.ALREADY_EXISTS);
}
}

@ -0,0 +1,69 @@
package com.sky.interceptor;
import com.sky.constant.JwtClaimsConstant;
import com.sky.constant.MessageConstant;
import com.sky.context.BaseContext;
import com.sky.properties.JwtProperties;
import com.sky.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* JWT
* JWT
* 401
*/
@Component
@Slf4j
public class JwtTokenAdminInterceptor implements HandlerInterceptor {
@Autowired
private JwtProperties jwtProperties; // 注入 JWT 配置属性,获取密钥和令牌名称
/**
* JWT
* Controller JWT
*
* @param request
* @param response
* @param handler Controller
* @return true false
* @throws Exception
*/
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 判断当前拦截到的是 Controller 的方法还是其他资源
if (!(handler instanceof HandlerMethod)) {
// 当前拦截到的不是动态方法,直接放行
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) handler;
// 1、从请求头中获取 JWT 令牌
String token = request.getHeader(jwtProperties.getAdminTokenName());
// 2、校验令牌
try {
log.info("JWT 校验: {}", token);
Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token); // 解析 JWT
Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString()); // 获取员工 ID
BaseContext.setCurrentId(empId); // 设置当前员工 ID 到上下文中
log.info("当前员工 ID: {}", empId);
// 3、校验通过放行请求
return true;
} catch (Exception ex) {
// 4、校验失败返回 401 状态码,表示未授权
log.error(MessageConstant.USER_NOT_LOGIN); // 打印未登录错误日志
response.setStatus(401); // 设置响应状态为 401
return false; // 拦截请求,不继续执行
}
}
}

@ -0,0 +1,68 @@
// 定义包名表示该类属于com.sky.interceptor包
package com.sky.interceptor;
// 导入所需的类和接口
import com.sky.constant.JwtClaimsConstant;
import com.sky.constant.MessageConstant;
import com.sky.context.BaseContext;
import com.sky.properties.JwtProperties;
import com.sky.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* JWTSpring MVCJWT
*/
@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {
// 自动注入JwtProperties用于获取JWT配置属性
@Autowired
private JwtProperties jwtProperties;
/**
* preHandle
*
* @param request
* @param response
* @param handler HandlerMethodControllerhandler
* @return truefalsefalseresponse
* @throws Exception
*/
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler){
// 判断当前拦截到的是Controller的方法还是其他资源
if (!(handler instanceof HandlerMethod)) {
// 当前拦截到的不是动态方法,直接放行
return true;
}
HandlerMethod handlerMethod= (HandlerMethod) handler;
// 1、从请求头中获取令牌
String token = request.getHeader(jwtProperties.getUserTokenName());
// 2、校验令牌
try {
log.info("jwt校验:{}", token);
// 使用JwtUtil解析JWT令牌
Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
// 从claims中获取用户ID并设置到BaseContext中供后续使用
Long empId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
BaseContext.setCurrentId(empId);
log.info("当前用户id:{}", empId);
// 3、通过放行
return true;
} catch (Exception ex) {
// 4、不通过响应401状态码
log.error(MessageConstant.USER_NOT_LOGIN);
response.setStatus(401);
return false;
}
}
}

@ -0,0 +1,78 @@
package com.sky.mapper;
import com.github.pagehelper.Page;
import com.sky.annotation.AutoFill;
import com.sky.dto.CategoryDTO;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.entity.Category;
import com.sky.enumeration.OperationType;
import com.sky.result.PageResult;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.aspectj.weaver.ast.Or;
import java.util.List;
/**
* CategoryMapperMyBatisCategory
* MyBatis
* MyBatisSQL便
*/
@Mapper
public interface CategoryMapper {
/**
* CategoryPageQueryDTO
* MyBatisSQLMyBatisSQLPage<Category>
* Page<Category>便
*
* @param categoryPageQueryDTO 便
* @return Page<Category>Category
*/
Page<Category> pageQuery(CategoryPageQueryDTO categoryPageQueryDTO);
/**
* CategoryDTOCategoryDTO
* MyBatisSQLList<Category>
* List<Category>便
*
* @param categoryDTO 便
* @return List<Category>Category
*/
List<Category> query(CategoryDTO categoryDTO);
/**
* idLongMyBatis@DeleteSQL
* "delete from category where id=#{id}"SQLcategoryid
*
*
* @param id idcategory
*/
@Delete("delete from category where id=#{id}")
void delete(Long id);
/**
* Category
* 使@AutoFillOperationType.UPDATE
* MyBatisSQL
*
*
* @param category
*/
@AutoFill(OperationType.UPDATE)
void updateCategory(Category category);
/**
* Category
* 使@AutoFillOperationType.INSERT@Insert
* @InsertSQLSQLCategorycategory
*
*
* @param category SQLcategory
*/
@AutoFill(OperationType.INSERT)
@Insert("insert into category(type,name,sort,status,create_time,create_user,update_time,update_user)" +
"values (#{type},#{name},#{sort},#{status},#{createTime},#{createUser},#{updateTime},#{updateUser})")
void save(Category category);
}

@ -0,0 +1,115 @@
package com.sky.mapper;
import com.github.pagehelper.Page;
import com.sky.annotation.AutoFill;
import com.sky.dto.DishPageQueryDTO;
import com.sky.entity.Dish;
import com.sky.entity.DishFlavor;
import com.sky.entity.Setmeal;
import com.sky.entity.SetmealDish;
import com.sky.enumeration.OperationType;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Mapper // 标记为 MyBatis 的 Mapper 接口,表明这是 MyBatis 对数据库操作的接口
public interface DishMapper {
/**
*
*
* @param dishPageQueryDTO
* @return
*/
Page<Dish> pageQuery(DishPageQueryDTO dishPageQueryDTO);
/**
*
*
* @param dish
*/
@AutoFill(OperationType.INSERT) // 自动填充操作,标记为插入操作
void save(Dish dish);
/**
*
*
* @param flavors
*/
void insertBatchFlavors(List<DishFlavor> flavors);
/**
*
*
* @param ids ID
*/
void deleteBatch(ArrayList<Long> ids);
/**
* ID
*
* @param ids ID
* @return
*/
ArrayList<Dish> getByIdBatch(ArrayList<Long> ids);
/**
* ID
*
* @param ids ID
* @return
*/
Integer countMealDish(ArrayList<Long> ids);
/**
*
*
* @param dish
*/
@AutoFill(OperationType.UPDATE) // 自动填充操作,标记为更新操作
void updateDish(Dish dish);
/**
*
*
* @param flavors
*/
void deleteBatchFlavors(List<DishFlavor> flavors);
/**
* ID
*
* @param id ID
* @return
*/
ArrayList<DishFlavor> getFlavorById(Long id);
/**
* ID
*
* @param categoryId ID
* @param status
* @return
*/
ArrayList<Dish> getByCategoryId(Long categoryId, Integer status);
/**
* ID
*
* @param id ID
* @return
*/
@Select("select * from dish where id=#{id}")
Dish getById(Long id);
/**
*
*
* @param map
* @return
*/
Integer countByMap(Map map);
}

@ -0,0 +1,59 @@
// 定义包名表示该类属于com.sky.mapper包
package com.sky.mapper;
// 导入所需的类和注解
import com.github.pagehelper.Page;
import com.sky.annotation.AutoFill;
import com.sky.dto.EmployeePageQueryDTO;
import com.sky.entity.Employee;
import com.sky.enumeration.OperationType;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
// 使用@Mapper注解标记这是一个MyBatis的Mapper接口
@Mapper
public interface EmployeeMapper {
/**
*
*
* @param username
* @return
*/
@Select("select * from employee where username = #{username}")
Employee getByUsername(String username);
/**
*
*
* @param employee
*/
@AutoFill(OperationType.INSERT)
@Insert("insert into employee(name,username,password,phone,sex,id_number,create_time,update_time,create_user,update_user,status)" +
" values(#{name},#{username},#{password},#{phone},#{sex},#{idNumber},#{createTime},#{updateTime},#{createUser},#{updateUser},#{status})")
void save(Employee employee);
/**
*
*
* @param employeePageQueryDTO
* @return
*/
Page<Employee> pageQuery(EmployeePageQueryDTO employeePageQueryDTO);
/**
*
*/
@AutoFill(OperationType.UPDATE)
void update(Employee employee);
/**
* id
*
* @param id ID
* @return
*/
@Select("select * from employee where id=#{id}")
Employee getById(Long id);
}

@ -0,0 +1,125 @@
package com.sky.mapper;
import com.github.pagehelper.Page;
import com.sky.dto.OrdersPageQueryDTO;
import com.sky.entity.OrderDetail;
import com.sky.entity.Orders;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
/**
* OrderMapperMyBatisOrders
* MyBatisSQL
*
*/
@Mapper
public interface OrderMapper {
/**
* 使@SelectSQLordersstatus
* Integerstatus"select count(id) from orders where status = #{status}"SQL
* Integer便
*
* @param status 01
* @return Integer便
*/
@Select("select count(id) from orders where status = #{status}")
Integer countStatus(Integer status) ;
/**
* OrdersPageQueryDTO
* MyBatisSQLOrdersPageQueryDTOSQLPage<Orders>
* Page<Orders>便便
*
* @param ordersPageQueryDTO 便
* @return Page<Orders>Orders
*/
Page<Orders> pageQuery(OrdersPageQueryDTO ordersPageQueryDTO);
/**
* Orders
* MyBatisSQLOrders@InsertSQLMyBatis
* Ordersorders
*
* @param orders MyBatisorders
*/
void insert(Orders orders);
/**
* 使@SelectSQLordersorderNumber
* StringorderNumber"select * from orders where number = #{orderNumber}"SQL
* Orders
*
* @param orderNumber orders
* @return Orders
*/
@Select("select * from orders where number = #{orderNumber}")
Orders getByNumber(String orderNumber);
/**
* Orders
* MyBatisSQL
*
*
* @param orders
*/
void update(Orders orders);
/**
* IntegerpendingPayment
* LocalDateTimetimeMyBatis@Param使SQL
* SQLList<Orders>
* 便
*
* @param pendingPayment
* @param time
* @return List<Orders>Orders便
*/
List<Orders> getByStatusAndOrderTimeLT(@Param("pendingPayment") Integer pendingPayment, @Param("time") LocalDateTime time);
/**
* List<Orders>ordersListOrdersid
* IntegerstatusMyBatis@Param使SQL
* SQL
*
* @param ordersList
* @param status ordersList使10
*/
void updateBatchStatus(@Param("ordersList") List<Orders> ordersList, @Param("status") Integer status);
/**
* orderId使@SelectSQLordersidid
* Longid"select * from orders where id=#{id}"SQL
* Ordersidid
*
* @param id orders
* @return Ordersid
*/
@Select("select * from orders where id=#{id}")
Orders getById(Long id);
/**
* MapmapMap
* MyBatis@Param"map"使SQLSQLMapSQL
* Integer便
*
* @param map Map
* @return Integer便
*/
Integer countByMap(@Param("map") Map map);
/**
* MapmapMap
* MyBatis@Param"map"使SQLSQLMapSQL
* Double便
*
* @param map Map
* @return Double便
*/
Double sumByMap(@Param("map") Map map);
}

@ -0,0 +1,73 @@
package com.sky.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
@Mapper // 标记为 MyBatis 的 Mapper 接口,用于与数据库交互
public interface ReportMapper {
/**
*
*
*
* @param map
* @return
*/
@Select("select sum(amount) from orders where status=#{status} and checkout_time>#{begin} and checkout_time<#{end}")
Double sumByMap(HashMap<String, Object> map);
/**
*
*
*
* @param map
* @return
*/
@Select("select count(id) from user where create_time>#{begin} and create_time<#{end}")
Integer sumUserByDay(HashMap<String, Object> map);
/**
*
*
*
* @param map
* @return
*/
@Select("select count(*) from user where create_time<#{end}")
Integer sumUser(HashMap<String, Object> map);
/**
*
*
*
* @param map
* @return
*/
@Select("select count(*) from orders where order_time>#{begin} and order_time<#{end}")
Integer sumNewOrder(HashMap<String, Object> map);
/**
*
*
*
* @param map
* @return
*/
@Select("select count(*) from orders where checkout_time>#{begin} and checkout_time<#{end} and status=#{status}")
Integer sumOrder(HashMap<String, Object> map);
/**
*
*
*
* @param map
* @return
*/
@Select("select od.name name, sum(od.number) number from order_detail od, orders o where od.order_id=o.id and status=#{status} and o.order_time>#{begin} and o.order_time<#{end} " +
"group by name order by number desc")
ArrayList<HashMap<String, Object>> salesTop10Report(HashMap<String, Object> map);
}

@ -0,0 +1,116 @@
// 定义包名表示该类属于com.sky.mapper包
package com.sky.mapper;
// 导入所需的类和注解
import com.github.pagehelper.Page;
import com.sky.annotation.AutoFill;
import com.sky.dto.SetmealDTO;
import com.sky.entity.SetmealDish;
import com.sky.enumeration.OperationType;
import com.sky.dto.SetmealPageQueryDTO;
import com.sky.entity.Setmeal;
import com.sky.vo.DishItemVO;
import com.sky.vo.SetmealVO;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
// 使用@Mapper注解标记这是一个MyBatis的Mapper接口
@Mapper
public interface SetmealMapper {
/**
*
*
* @param map
* @return
*/
Integer countByMap(Map map);
/**
*
*
* @param setmeal
* @return
*/
List<Setmeal> list(Setmeal setmeal);
/**
* id
*
* @param setmealId ID
* @return
*/
@Select("select sd.name, sd.copies, d.image, d.description " +
"from setmeal_dish sd left join dish d on sd.dish_id = d.id " +
"where sd.setmeal_id = #{setmealId}")
List<DishItemVO> getDishItemBySetmealId(Long setmealId);
/**
*
*
* @param setmealPageQueryDTO
* @return
*/
Page<Setmeal> pageQuery(SetmealPageQueryDTO setmealPageQueryDTO);
/**
*
*
* @param setmeal
*/
@AutoFill(OperationType.UPDATE)
void updateSetmeal(Setmeal setmeal);
/**
* id
*
* @param id ID
*/
@Delete("delete from setmeal_dish where setmeal_id=#{id}")
void deleteSetmealDish(Long id);
/**
*
*
* @param setmealDishes
*/
void insertBatchSetmealDish(List<SetmealDish> setmealDishes);
/**
* id
*
* @param id ID
* @return
*/
@Select("select * from setmeal where id=#{id}")
Setmeal getBySetmealId(Long id);
/**
* id
*
* @param id ID
* @return
*/
@Select("select * from setmeal_dish where setmeal_id=#{id}")
List<SetmealDish> getSetmealDishById(Long id);
/**
* id
*
* @param ids ID
*/
void batchDeleteSetmeal(ArrayList<Long> ids);
/**
*
*
* @param setmeal
*/
@AutoFill(OperationType.INSERT)
void insertSetmeal(Setmeal setmeal);
}

@ -0,0 +1,59 @@
package com.sky.mapper;
import com.sky.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.Map;
/**
* UserMapperMyBatisUser
* openididMyBatisSQL
*
*/
@Mapper
public interface UserMapper {
/**
* openid使@SelectSQLuseropenidopenid
* Stringopenidopenidopenid使
* "select * from user where openid=#{openid}"SQLUseropenid
* openid
*
* @param openid user
* @return Useropenid
*/
@Select("select * from user where openid=#{openid}")
User getByOpenId(String openid);
/**
* User
* MyBatisSQL@InsertSQLMyBatis
* Useruser
*
* @param user MyBatisuser
*/
void insertUser(User user);
/**
* id使@SelectSQLuseriduserId
* LonguserId"select * from user where id=#{userId}"SQL
* Useridid
*
* @param userId user
* @return Userid
*/
@Select("select * from user where id=#{userId}")
User getById(Long userId);
/**
* MapmapMap
* MyBatis@Param"map"使SQLSQLMapSQL
* Integer便
*
* @param map Map
* @return Integer便
*/
Integer countByMap(@Param("map") Map map);
}

@ -0,0 +1,63 @@
package com.sky.service;
import com.sky.entity.AddressBook;
import java.util.List;
/**
* AddressBookService簿AddressBook
* 簿使
* 簿便
*/
public interface AddressBookService {
/**
* AddressBookid簿
* List<AddressBook>AddressBook
* 便使
*
* @param addressBook 簿id
* @return List<AddressBook>簿AddressBook簿
*/
List<AddressBook> list(AddressBook addressBook);
/**
* AddressBook
* 簿
*
* @param addressBook 簿
*/
void save(AddressBook addressBook);
/**
* idLongidAddressBook
* 便使
*
* @param id id簿
* @return AddressBookid
*/
AddressBook getById(Long id);
/**
* AddressBook
* id
*
* @param addressBook
*/
void update(AddressBook addressBook);
/**
* AddressBookid
* 簿便便使
*
* @param addressBook id
*/
void setDefault(AddressBook addressBook);
/**
* idLongid簿id
*
*
* @param id id簿
*/
void deleteById(Long id);
}

@ -0,0 +1,68 @@
package com.sky.service;
import com.sky.dto.CategoryDTO;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.entity.Category;
import com.sky.result.PageResult;
import java.util.List;
public interface CategoryService {
/**
*
*
*
*
* @param categoryPageQueryDTO
* @return
*/
PageResult pageQuery(CategoryPageQueryDTO categoryPageQueryDTO);
/**
*
*
*
*
* @param type 1 2
* @return
*/
List<Category> query(Integer type);
/**
*
*
* ID
*
* @param id ID
*/
void delete(Long id);
/**
*
*
* DTO
*
* @param categoryDTO DTO
*/
void updateCategory(CategoryDTO categoryDTO);
/**
*
*
*
*
* @param status 1 0
* @param id ID
*/
void startOrStop(Integer status, Long id);
/**
*
*
* DTO
*
* @param categoryDTO DTO
*/
void save(CategoryDTO categoryDTO);
}

@ -0,0 +1,25 @@
// 定义一个名为com.sky.service的包用于存放服务相关的类和接口
package com.sky.service;
// 导入Spring框架中的@Service注解用于声明一个服务组件
import org.springframework.stereotype.Service;
// 导入MultipartFile接口用于处理上传的文件
import org.springframework.web.multipart.MultipartFile;
// 导入Java的IOException类用于处理可能发生的IO异常
import java.io.IOException;
// 使用@Service注解标记这个接口表明它是一个Spring管理的服务组件
@Service
// 声明一个名为CommonService的接口
public interface CommonService {
/**
*
*
* @param file MultipartFile
* @return
* @throws IOException IOIOException
*/
String upload(MultipartFile file) throws IOException;
}

@ -0,0 +1,70 @@
package com.sky.service;
import com.sky.dto.EmployeeDTO;
import com.sky.dto.EmployeeLoginDTO;
import com.sky.dto.EmployeePageQueryDTO;
import com.sky.entity.Employee;
import com.sky.result.PageResult;
/**
* EmployeeServiceEmployee
* 使
* 便id
*/
public interface EmployeeService {
/**
* EmployeeLoginDTO
* Employee
*
*
* @param employeeLoginDTO
* @return Employeenull
*/
Employee login(EmployeeLoginDTO employeeLoginDTO);
/**
* EmployeeDTO
*
*
* @param employeeDTO
*/
void save(EmployeeDTO employeeDTO);
/**
* EmployeePageQueryDTO
* PageResultPageResult
* 便
*
* @param employeePageQueryDTO 便
* @return PageResulttotalrecords便
*/
PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO);
/**
* Integerstatus10
* Longididid
* 使使
*
* @param status
* @param id id
*/
void startOrStop(Integer status, Long id);
/**
* idLongid
* idEmployee
* 便使
*
* @param id id
*/
Employee getById(Long id);
/**
* EmployeeDTO
* id
*
* @param employeeDTO
*/
void update(EmployeeDTO employeeDTO);
}

@ -0,0 +1,159 @@
package com.sky.service;
import com.sky.dto.*;
import com.sky.result.PageResult;
import com.sky.vo.OrderPaymentVO;
import com.sky.vo.OrderStatisticsVO;
import com.sky.vo.OrderSubmitVO;
import com.sky.vo.OrderVO;
import java.util.ArrayList;
public interface OrderService {
/**
*
*
*
*
* @param id ID
*/
void complete(Long id);
/**
*
*
*
*
* @param id ID
*/
void delivery(Long id);
/**
*
*
*
*
* @param ordersCancelDTO ID
* @throws Exception
*/
void cancel(OrdersCancelDTO ordersCancelDTO) throws Exception;
/**
*
*
*
*
* @param ordersRejectionDTO ID
* @throws Exception
*/
void rejection(OrdersRejectionDTO ordersRejectionDTO) throws Exception;
/**
*
*
*
*
* @param ordersConfirmDTO ID
*/
void confirm(OrdersConfirmDTO ordersConfirmDTO);
/**
*
*
*
*
* @return
*/
OrderStatisticsVO statistics();
/**
*
*
*
*
* @param ordersPageQueryDTO
* @return
*/
PageResult conditionSearch(OrdersPageQueryDTO ordersPageQueryDTO);
/**
*
*
*
*
* @param id ID
* @throws Exception
*/
void userCancelById(Long id) throws Exception;
/**
*
*
*
*
* @param id ID
* @return
*/
OrderVO details(Long id);
/**
*
*
*
*
* @param ordersDTO
* @return ID
*/
OrderSubmitVO submit(OrdersDTO ordersDTO);
/**
*
*
*
*
* @param ordersPaymentDTO DTO
* @return
* @throws Exception
*/
OrderPaymentVO payment(OrdersPaymentDTO ordersPaymentDTO) throws Exception;
/**
*
*
*
*
* @param outTradeNo
*/
void paySuccess(String outTradeNo);
/**
*
*
*
*
* @param id ID
*/
void reminder(Long id);
/**
*
*
*
*
* @param page
* @param pageSize
* @param status
* @return
*/
PageResult pageQuery4User(int page, int pageSize, Integer status);
/**
*
*
*
*
* @param id ID
*/
void repetition(Long id);
}

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

Loading…
Cancel
Save