Compare commits

..

No commits in common. 'main' and 'branch_wangheng' have entirely different histories.

@ -1,10 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Encoding">
<file url="file://$PROJECT_DIR$/sky/sky-common/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/sky/sky-pojo/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/sky/sky-server/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/sky/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/sky/src/main/resources" charset="UTF-8" />
</component>
</project>

@ -1,6 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<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" />
</component>
</project>

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

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

@ -1,109 +0,0 @@
<?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,6 +1,8 @@
<<<<<<< HEAD
# 苍穹外卖
#### 介绍
外卖项目源码
黑马苍穹外卖项目源码,已完结
#### 软件架构
软件架构说明

@ -1,43 +0,0 @@
/**
* 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";
*/
}

@ -1,103 +0,0 @@
package com.sky.constant;
/**
*
*
*/
public class MessageConstant {
/**
*
*/
public static final String PASSWORD_ERROR = "密码错误";
/**
* 访
*/
public static final String ACCOUNT_NOT_FOUND = "账号不存在";
/**
*
*/
public static final String ACCOUNT_LOCKED = "账号被锁定";
/**
*
*/
public static final String ALREADY_EXISTS = "已存在";
/**
*
*/
public static final String UNKNOWN_ERROR = "未知错误";
/**
*
*/
public static final String USER_NOT_LOGIN = "用户未登录";
/**
*
*/
public static final String CATEGORY_BE_RELATED_BY_SETMEAL = "当前分类关联了套餐,不能删除";
/**
*
*/
public static final String CATEGORY_BE_RELATED_BY_DISH = "当前分类关联了菜品,不能删除";
/**
*
*/
public static final String SHOPPING_CART_IS_NULL = "购物车数据为空,不能下单";
/**
* 簿
*/
public static final String ADDRESS_BOOK_IS_NULL = "用户地址为空,不能下单";
/**
*
*/
public static final String LOGIN_FAILED = "登录失败";
/**
*
*/
public static final String UPLOAD_FAILED = "文件上传失败";
/**
*
*/
public static final String SETMEAL_ENABLE_FAILED = "套餐内包含未启售菜品,无法启售";
/**
*
*/
public static final String PASSWORD_EDIT_FAILED = "密码修改失败";
/**
*
*/
public static final String DISH_ON_SALE = "起售中的菜品不能删除";
/**
*
*/
public static final String SETMEAL_ON_SALE = "起售中的套餐不能删除";
/**
*
*/
public static final String DISH_BE_RELATED_BY_SETMEAL = "当前菜品关联了套餐,不能删除";
/**
*
*/
public static final String ORDER_STATUS_ERROR = "订单状态错误";
/**
* ID
*/
public static final String ORDER_NOT_FOUND = "订单不存在";
}

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

@ -1,43 +0,0 @@
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();
}
}

@ -1,20 +0,0 @@
package com.sky.enumeration;
/**
*
* SQL
*/
public enum OperationType {
/**
*
* 使SQL UPDATE
*/
UPDATE,
/**
*
* 使SQL INSERT
*/
INSERT;
}

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

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

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

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

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

@ -1,19 +0,0 @@
package com.sky.exception;
/**
* PasswordEditFailedException
* BaseExceptionBaseException
* 便
*/
public class PasswordEditFailedException extends BaseException {
/**
* PasswordEditFailedException
*
* @param msg BaseException
* 便msg"密码长度不符合要求导致修改失败"
*/
public PasswordEditFailedException(String msg) {
super(msg);
}
}

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

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

@ -1,30 +0,0 @@
package com.sky.exception;
/**
* UserNotLoginException
*
* 便
* BaseExceptionBaseException
* 便
*/
public class UserNotLoginException extends BaseException {
/**
*
* 使
* 使便
*/
public UserNotLoginException() {
}
/**
*
*
* @param msg BaseException
*
* msg"用户未登录,无法访问个人资料页面"
*/
public UserNotLoginException(String msg) {
super(msg);
}
}

@ -1,77 +0,0 @@
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);
}
}

@ -1,53 +0,0 @@
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;
}

@ -1,37 +0,0 @@
package com.sky.properties;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
/**
* ReportExcelPropertiesExcel
* Spring Boot便使
* Excelsheet
*/
@Component
// 使用@Component注解将该类标记为Spring的组件这样Spring容器能够扫描并管理它使其可以在项目的其他地方通过依赖注入等方式使用。
@ConfigurationProperties(prefix = "sky.excel")
// @ConfigurationProperties注解用于指定配置属性的前缀Spring Boot会自动将配置文件中以"sky.excel"为前缀的属性值绑定到该类对应的成员变量上。
@Data
// 使用Lombok的@Data注解它会自动为类生成常用的方法比如Getter、Setter、toString、equals和hashCode等方法简化代码编写提高开发效率。
public class ReportExcelProperties {
/**
* Excel
*
* Spring Boot"sky.excel.filePath"
*/
private String filePath;
/**
* Excelsheet
* "sky.excel.sheet"便Excel
* "sky.excel.sheet[0]=Sheet1""sky.excel.sheet[1]=Sheet2"{"Sheet1", "Sheet2"}
*/
private String[] sheet;
}

@ -1,74 +0,0 @@
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;
}

@ -1,76 +0,0 @@
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;
}
}

@ -1,113 +0,0 @@
package com.sky.utils;
import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.io.ByteArrayInputStream;
/**
* AliOssUtilOSS
* OSSJava SDK便Spring BootOSSOSS访
*/
@Data
// 使用Lombok的@Data注解会自动为类中的私有成员变量生成对应的Getter、Setter方法以及toString、equals和hashCode等方法简化代码编写。
@Slf4j
// 使用Lombok的@Slf4j注解会在类中自动生成一个名为log的Slf4j日志记录器方便在代码中记录相关的操作信息、异常等情况便于调试和监控。
@Component
// 使用@Component注解将该类标记为Spring框架中的一个组件这样Spring容器能够自动扫描并管理它使得该类可以在项目的其他地方通过依赖注入等方式被使用。
@AllArgsConstructor
// 使用Lombok的@AllArgsConstructor注解会自动生成一个包含所有成员变量的构造函数方便在创建类实例时进行参数注入等操作。
@NoArgsConstructor
// 使用Lombok的@NoArgsConstructor注解会自动生成一个无参构造函数满足某些场景下需要默认构造函数的需求例如在一些框架进行对象实例化时可能会调用无参构造函数。
public class AliOssUtil {
/**
* OSS访Endpoint
* OSSEndpointOSS
* "oss-cn-hangzhou.aliyuncs.com"OSSapplication.propertiesapplication.yml
*/
private String endpoint;
/**
* OSS访IDAccess Key ID
* Access Key SecretOSSOSSAccess Key IDAccess Key Secret
*
*/
private String accessKeyId;
/**
* OSS访Access Key Secret
* Access Key ID使访OSS
*
*/
private String accessKeySecret;
/**
* OSSBucket
* OSSOSS
* 便使
*/
private String bucketName;
/**
* OSSOSS访
*
* @param bytes 便OSS
* @param objectName OSSOSSOSS
* @return OSS访URL"https://BucketName.Endpoint/ObjectName"便使访
*/
public String upload(byte[] bytes, String objectName) {
// 创建OSSClient实例。
// 通过OSSClientBuilder构建器使用传入的endpoint、accessKeyId和accessKeySecret来创建一个与阿里云OSS服务进行交互的客户端实例
// 该客户端实例将用于后续的文件上传等操作它封装了与OSS服务通信的底层细节提供了一系列方便的方法来操作OSS资源。
OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
try {
// 创建PutObject请求。
// 使用ossClient的putObject方法创建一个文件上传请求将指定的字节数组内容通过ByteArrayInputStream包装后上传到指定的bucketName存储桶中以objectName作为对象名称。
// 这个操作实际上就是向OSS服务发送请求将本地的文件数据传输到云端存储桶里如果上传过程中出现OSS相关的异常情况会被相应的异常处理机制捕获。
ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(bytes));
} catch (OSSException oe) {
// 捕获OSSException异常该异常表示请求已经发送到OSS服务端但由于某些原因如权限问题、资源不存在等被服务端拒绝并返回了错误响应信息。
// 下面的代码主要是将OSS服务端返回的详细错误信息打印出来方便开发人员定位问题例如错误消息、错误代码、请求ID以及主机ID等信息都有助于排查问题所在。
System.out.println("Caught an OSSException, which means your request made it to OSS, "
+ "but was rejected with an error response for some reason.");
System.out.println("Error Message:" + oe.getErrorMessage());
System.out.println("Error Code:" + oe.getErrorCode());
System.out.println("Request ID:" + oe.getRequestId());
System.out.println("Host ID:" + oe.getHostId());
} catch (ClientException ce) {
// 捕获ClientException异常该异常表示客户端在尝试与OSS服务进行通信时遇到了严重的内部问题比如无法访问网络等情况
// 通常是客户端自身环境或者配置方面的问题导致无法正常连接到OSS服务这里同样打印出错误消息以便分析是哪里出现了通信故障。
System.out.println("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
System.out.println("Error Message:" + ce.getMessage());
} finally {
if (ossClient!= null) {
// 无论文件上传是否成功都需要关闭OSSClient实例释放相关的资源避免资源泄露保证程序的稳定性和性能。
ossClient.shutdown();
}
}
// 文件访问路径规则 https://BucketName.Endpoint/ObjectName
StringBuilder stringBuilder = new StringBuilder("https://");
stringBuilder
.append(bucketName)
.append(".")
.append(endpoint)
.append("/")
.append(objectName);
log.info("文件上传到:{}", stringBuilder);
return stringBuilder.toString();
}
}

@ -1,205 +0,0 @@
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();
}
}

@ -1,233 +0,0 @@
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);
}
}

@ -1,41 +0,0 @@
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;
}

@ -1,17 +0,0 @@
// 定义了一个名为DataOverViewQueryDTO的类它位于com.sky.dto包中。
// 这个类实现了Serializable接口这意味着它可以被序列化通常用于网络传输或持久化到文件中。
// 使用Lombok提供的注解@Data这个注解自动为类生成getter和setter方法以及equals、hashCode和toString方法。
// 使用@Builder注解这个注解自动为类生成一个Builder模式的构建器用于创建类的实例。
// 使用@NoArgsConstructor注解这个注解自动为类生成一个无参的构造函数。
// 使用@AllArgsConstructor注解这个注解自动为类生成一个包含所有成员变量的构造函数。
public class DataOverViewQueryDTO implements Serializable {
// 成员变量begin类型为LocalDateTime表示查询的开始时间。
private LocalDateTime begin;
// 成员变量end类型为LocalDateTime表示查询的结束时间。
private LocalDateTime end;
}

@ -1,67 +0,0 @@
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<>();
}

@ -1,33 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,29 +0,0 @@
// 导入所需的包
package com.sky.dto;
// 导入Swagger注解用于生成API文档
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 导入Lombok注解用于简化Java对象的创建
import lombok.Data;
// 导入Serializable接口使得类可以被序列化
import java.io.Serializable;
// 使用@Data注解Lombok会自动为这个类生成getter和setter方法以及equals、hashCode和toString方法。
@Data
// 使用@ApiModel注解指定这个类是Swagger文档中的一个模型并提供模型的描述。
@ApiModel(description = "员工登录时传递的数据模型")
// 声明这个类实现了Serializable接口这意味着它可以被序列化通常用于网络传输或持久化到文件中。
public class EmployeeLoginDTO implements Serializable {
// 使用@ApiModelProperty注解为username字段提供API文档中的描述。
@ApiModelProperty("用户名")
// 定义一个私有字段username类型为String用于存储员工的用户名。
private String username;
// 使用@ApiModelProperty注解为password字段提供API文档中的描述。
@ApiModelProperty("密码")
// 定义一个私有字段password类型为String用于存储员工的密码。
private String password;
}

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

@ -1,22 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,28 +0,0 @@
// 导入所需的包
package com.sky.dto;
// 导入Lombok注解用于简化Java对象的创建
import lombok.Data;
// 导入Serializable接口使得类可以被序列化
import java.io.Serializable;
// 使用@Data注解Lombok会自动为这个类生成getter和setter方法以及equals、hashCode和toString方法。
@Data
// 声明这个类实现了Serializable接口这意味着它可以被序列化通常用于网络传输或持久化到文件中。
public class OrdersConfirmDTO implements Serializable {
// 定义一个私有字段id类型为Long用于存储订单的唯一标识符。
private Long id;
// 定义一个私有字段status类型为Integer用于存储订单的状态。
// 订单状态的不同值代表不同的订单处理阶段:
// 1 - 待付款
// 2 - 待接单
// 3 - 已接单
// 4 - 派送中
// 5 - 已完成
// 6 - 已取消
// 7 - 退款
private Integer status;
}

@ -1,135 +0,0 @@
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;
}

@ -1,23 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,21 +0,0 @@
// 导入所需的包
package com.sky.dto;
// 导入Lombok注解用于简化Java对象的创建
import lombok.Data;
// 导入Serializable接口使得类可以被序列化
import java.io.Serializable;
// 使用@Data注解Lombok会自动为这个类生成getter和setter方法以及equals、hashCode和toString方法。
@Data
// 声明这个类实现了Serializable接口这意味着它可以被序列化通常用于网络传输或持久化到文件中。
public class OrdersRejectionDTO implements Serializable {
// 定义一个私有字段id类型为Long用于存储订单的唯一标识符。
private Long id;
// 定义一个私有字段rejectionReason类型为String用于存储订单被拒绝的原因。
// 这个字段用于在订单被拒绝时提供详细的解释或理由。
private String rejectionReason;
}

@ -1,75 +0,0 @@
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;
}

@ -1,46 +0,0 @@
// 定义包名表示该类属于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<>();
}

@ -1,31 +0,0 @@
// 导入所需的包
package com.sky.dto;
// 导入Lombok注解用于简化Java对象的创建
import lombok.Data;
// 导入Serializable接口使得类可以被序列化
import java.io.Serializable;
// 使用@Data注解Lombok会自动为这个类生成getter和setter方法以及equals、hashCode和toString方法。
@Data
// 声明这个类实现了Serializable接口这意味着它可以被序列化通常用于网络传输或持久化到文件中。
public class SetmealPageQueryDTO implements Serializable {
// 定义一个私有字段page类型为int用于存储分页查询的当前页码。
private int page;
// 定义一个私有字段pageSize类型为int用于存储分页查询中每页显示的记录数。
private int pageSize;
// 定义一个私有字段name类型为String用于存储套餐名称的查询条件。
private String name;
// 定义一个私有字段categoryId类型为Integer用于存储分类id的查询条件。
// 分类id用于筛选特定分类下的套餐。
private Integer categoryId;
// 定义一个私有字段status类型为Integer用于存储状态的查询条件。
// 状态字段的值0表示禁用1表示启用用于筛选启用或禁用的套餐。
private Integer status;
}

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

@ -1,70 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,56 +0,0 @@
// 定义了一个名为com.sky.entity的包用于存放实体类
package com.sky.entity;
// 导入了Lombok库中的注解用于简化实体类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入了Serializable接口使得Category类的对象可以被序列化用于网络传输或文件存储
import java.io.Serializable;
// 导入了LocalDateTime类用于存储日期和时间
import java.time.LocalDateTime;
// 使用@Data注解自动生成getter和setter方法以及equals、hashCode和toString方法
@Data
// 使用@Builder注解自动生成builder模式代码方便对象的构建
@Builder
// 使用@NoArgsConstructor注解自动生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解自动生成包含所有属性的构造方法
@AllArgsConstructor
// 声明Category类实现了Serializable接口表示该类的对象可以被序列化
public class Category implements Serializable {
// 定义了一个serialVersionUID用于在序列化时保持版本的一致性
private static final long serialVersionUID = 1L;
// 定义了一个id属性类型为Long表示分类的唯一标识
private Long id;
// 定义了一个type属性类型为Integer表示分类的类型1表示菜品分类2表示套餐分类
private Integer type;
// 定义了一个name属性类型为String表示分类的名称
private String name;
// 定义了一个sort属性类型为Integer表示分类的顺序
private Integer sort;
// 定义了一个status属性类型为Integer表示分类的状态0表示禁用1表示启用
private Integer status;
// 定义了一个createTime属性类型为LocalDateTime表示分类的创建时间
private LocalDateTime createTime;
// 定义了一个updateTime属性类型为LocalDateTime表示分类的更新时间
private LocalDateTime updateTime;
// 定义了一个createUser属性类型为Long表示创建分类的用户ID
private Long createUser;
// 定义了一个updateUser属性类型为Long表示更新分类的用户ID
private Long updateUser;
}

@ -1,93 +0,0 @@
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;
}

@ -1,71 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,59 +0,0 @@
// 定义了一个名为com.sky.entity的包用于存放实体类
package com.sky.entity;
// 导入了Lombok库中的注解用于简化实体类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入了Serializable接口使得OrderDetail类的对象可以被序列化用于网络传输或文件存储
import java.io.Serializable;
// 导入了BigDecimal类用于精确表示货币金额
import java.math.BigDecimal;
/**
*
*/
// 使用@Data注解自动生成getter和setter方法以及equals、hashCode和toString方法
@Data
// 使用@Builder注解自动生成builder模式代码方便对象的构建
@Builder
// 使用@NoArgsConstructor注解自动生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解自动生成包含所有属性的构造方法
@AllArgsConstructor
// 声明OrderDetail类实现了Serializable接口表示该类的对象可以被序列化
public class OrderDetail implements Serializable {
// 定义了一个serialVersionUID用于在序列化时保持版本的一致性
private static final long serialVersionUID = 1L;
// 定义了一个id属性类型为Long表示订单明细的唯一标识
private Long id;
// 定义了一个name属性类型为String表示订单明细的名称
private String name;
// 定义了一个orderId属性类型为Long表示所属订单的ID
private Long orderId;
// 定义了一个dishId属性类型为Long表示菜品的ID
private Long dishId;
// 定义了一个setmealId属性类型为Long表示套餐的ID
private Long setmealId;
// 定义了一个dishFlavor属性类型为String表示菜品的口味
private String dishFlavor;
// 定义了一个number属性类型为Integer表示订单明细的数量
private Integer number;
// 定义了一个amount属性类型为BigDecimal表示订单明细的金额
private BigDecimal amount;
// 定义了一个image属性类型为String表示订单明细的图片路径或URL
private String image;
}

@ -1,205 +0,0 @@
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;
}

@ -1,48 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,65 +0,0 @@
// 定义了一个名为com.sky.entity的包用于存放实体类
package com.sky.entity;
// 导入了Lombok库中的注解用于简化实体类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入了Serializable接口使得ShoppingCart类的对象可以被序列化用于网络传输或文件存储
import java.io.Serializable;
// 导入了BigDecimal类用于精确表示货币金额
import java.math.BigDecimal;
// 导入了LocalDateTime类用于存储日期和时间
import java.time.LocalDateTime;
/**
*
*/
// 使用@Data注解自动生成getter和setter方法以及equals、hashCode和toString方法
@Data
// 使用@Builder注解自动生成builder模式代码方便对象的构建
@Builder
// 使用@NoArgsConstructor注解自动生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解自动生成包含所有属性的构造方法
@AllArgsConstructor
// 声明ShoppingCart类实现了Serializable接口表示该类的对象可以被序列化
public class ShoppingCart implements Serializable {
// 定义了一个serialVersionUID用于在序列化时保持版本的一致性
private static final long serialVersionUID = 1L;
// 定义了一个id属性类型为Long表示购物车的唯一标识
private Long id;
// 定义了一个name属性类型为String表示购物车的名称或描述
private String name;
// 定义了一个userId属性类型为Long表示用户的ID
private Long userId;
// 定义了一个dishId属性类型为Long表示菜品的ID
private Long dishId;
// 定义了一个setmealId属性类型为Long表示套餐的ID
private Long setmealId;
// 定义了一个dishFlavor属性类型为String表示菜品的口味
private String dishFlavor;
// 定义了一个number属性类型为Integer表示商品的数量
private Integer number;
// 定义了一个amount属性类型为BigDecimal表示商品的总金额
private BigDecimal amount;
// 定义了一个image属性类型为String表示商品的图片路径或URL
private String image;
// 定义了一个createTime属性类型为LocalDateTime表示购物车创建的时间
private LocalDateTime createTime;
}

@ -1,72 +0,0 @@
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;
}

@ -1,37 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,31 +0,0 @@
// 定义了一个名为com.sky.vo的包用于存放视图对象类
package com.sky.vo;
// 导入了Lombok库中的注解用于简化类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入了Serializable接口使得DishOverViewVO类的对象可以被序列化用于网络传输或文件存储
import java.io.Serializable;
/**
*
*/
// 使用@Data注解自动生成getter和setter方法以及equals、hashCode和toString方法
@Data
// 使用@Builder注解自动生成builder模式代码方便对象的构建
@Builder
// 使用@NoArgsConstructor注解自动生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解自动生成包含所有属性的构造方法
@AllArgsConstructor
// 声明DishOverViewVO类实现了Serializable接口表示该类的对象可以被序列化
public class DishOverViewVO implements Serializable {
// 定义了一个sold属性类型为Integer表示已启售的菜品数量
private Integer sold;
// 定义了一个discontinued属性类型为Integer表示已停售的菜品数量
private Integer discontinued;
}

@ -1,92 +0,0 @@
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;
}

@ -1,40 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,40 +0,0 @@
// 定义了一个名为com.sky.vo的包用于存放视图对象类
package com.sky.vo;
// 导入了Lombok库中的注解用于简化类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入了Serializable接口使得OrderPaymentVO类的对象可以被序列化用于网络传输或文件存储
import java.io.Serializable;
/**
*
*/
// 使用@Data注解自动生成getter和setter方法以及equals、hashCode和toString方法
@Data
// 使用@Builder注解自动生成builder模式代码方便对象的构建
@Builder
// 使用@NoArgsConstructor注解自动生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解自动生成包含所有属性的构造方法
@AllArgsConstructor
// 声明OrderPaymentVO类实现了Serializable接口表示该类的对象可以被序列化
public class OrderPaymentVO implements Serializable {
// 定义了一个nonceStr属性类型为String表示随机字符串用于支付过程中的随机性
private String nonceStr;
// 定义了一个paySign属性类型为String表示签名用于验证支付请求的合法性
private String paySign;
// 定义了一个timeStamp属性类型为String表示时间戳用于记录支付请求的时间
private String timeStamp;
// 定义了一个signType属性类型为String表示签名算法用于指定签名的算法类型
private String signType;
// 定义了一个packageStr属性类型为String表示统一下单接口返回的prepay_id参数值用于后续支付流程
private String packageStr;
}

@ -1,59 +0,0 @@
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;
}

@ -1,41 +0,0 @@
// 定义包名表示该类属于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;
}

@ -1,36 +0,0 @@
// 定义了一个名为com.sky.vo的包用于存放视图对象类
package com.sky.vo;
// 导入了实体类Orders和OrderDetail以便在视图对象中使用
import com.sky.entity.OrderDetail;
import com.sky.entity.Orders;
// 导入了Lombok库中的注解用于简化类的编写
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入了Serializable接口使得OrderVO类的对象可以被序列化用于网络传输或文件存储
import java.io.Serializable;
// 导入了List接口用于存储订单详情列表
import java.util.List;
/**
* Orders
*/
// 使用@Data注解自动生成getter和setter方法以及equals、hashCode和toString方法
@Data
// 使用@NoArgsConstructor注解自动生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解自动生成包含所有属性的构造方法
@AllArgsConstructor
// 声明OrderVO类继承自Orders实体类并实现了Serializable接口表示该类的对象可以被序列化
public class OrderVO extends Orders implements Serializable {
// 定义了一个orderDishes属性类型为String表示订单中的菜品信息通常用于展示订单中包含的所有菜品的名称或描述
private String orderDishes;
// 定义了一个orderDetailList属性类型为List<OrderDetail>,表示订单详情列表,包含了订单中每个商品的详细信息
private List<OrderDetail> orderDetailList;
}

@ -1,35 +0,0 @@
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;
}

@ -1,66 +0,0 @@
// 定义包名表示该类属于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<>();
}

@ -1,38 +0,0 @@
// 定义了一个名为com.sky.vo的包用于存放视图对象类
package com.sky.vo;
// 导入了Lombok库中的注解用于简化类的编写
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入了Serializable接口使得TurnoverReportVO类的对象可以被序列化用于网络传输或文件存储
import java.io.Serializable;
/**
*
*/
// 使用@Data注解自动生成getter和setter方法以及equals、hashCode和toString方法
@Data
// 使用@Builder注解自动生成builder模式代码方便对象的构建
@Builder
// 使用@NoArgsConstructor注解自动生成无参构造方法
@NoArgsConstructor
// 使用@AllArgsConstructor注解自动生成包含所有属性的构造方法
@AllArgsConstructor
// 声明TurnoverReportVO类实现了Serializable接口表示该类的对象可以被序列化
public class TurnoverReportVO implements Serializable {
/**
*
* "2022-10-01,2022-10-02,2022-10-03"
*/
private String dateList;
/**
*
* "406.0,1520.0,75.0"
*/
private String turnoverList;
}

@ -1,41 +0,0 @@
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;
}

@ -1,97 +0,0 @@
// 定义包名表示该类属于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("自动填充操作类型参数异常!");
}
}
}

@ -1,35 +0,0 @@
// 导入所需的包
package com.sky.config;
// 导入Lombok提供的@Slf4j注解用于自动注入一个日志对象
import lombok.extern.slf4j.Slf4j;
// 导入Spring框架的配置注解用于声明这是一个配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// 导入Spring Data Redis的连接工厂接口
import org.springframework.data.redis.connection.RedisConnectionFactory;
// 导入Spring Data Redis的核心组件用于操作Redis
import org.springframework.data.redis.core.RedisTemplate;
// 导入Spring Data Redis的字符串序列化器
import org.springframework.data.redis.serializer.StringRedisSerializer;
// 使用@Configuration注解声明这个类是一个Spring配置类其中的Bean会被Spring容器自动扫描和管理。
@Configuration
// 使用@Slf4j注解自动为这个类注入一个日志对象方便记录日志信息。
@Slf4j
public class RedisConfiguration {
// 使用@Bean注解声明一个BeanSpring容器会调用这个方法来创建Bean并将其加入到容器中。
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 记录日志信息表示开始创建Redis模板对象。
log.info("开始创建redis模版对象...");
// 创建RedisTemplate实例泛型参数为Object表示键和值都可以是任意类型的对象。
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
// 设置连接工厂对象这个对象负责与Redis服务器建立连接。
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 设置Redis key的序列化器这里使用StringRedisSerializer表示key会被序列化为String类型。
redisTemplate.setKeySerializer(new StringRedisSerializer());
// 返回配置好的RedisTemplate对象它将被Spring容器管理。
return redisTemplate;
}
}

@ -1,132 +0,0 @@
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);
}
}

@ -1,134 +0,0 @@
// 定义包名表示该类属于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();
}
}

@ -1,68 +0,0 @@
// 导入所需的包
package com.sky.controller.admin;
// 导入项目中定义的消息常量类
import com.sky.constant.MessageConstant;
// 导入项目中定义的结果封装类
import com.sky.result.Result;
// 导入项目中定义的通用服务接口
import com.sky.service.CommonService;
// 导入Swagger注解用于生成API文档
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
// 导入Lombok提供的@Slf4j注解用于自动注入一个日志对象
import lombok.extern.slf4j.Slf4j;
// 导入Spring框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架的映射注解
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
// 导入Spring框架的文件上传组件
import org.springframework.web.multipart.MultipartFile;
// 导入Java IO异常类
import java.io.IOException;
// 使用@RestController注解声明这个类是一个Spring MVC的控制器并且返回的数据会自动以JSON格式响应。
@RestController
// 使用@RequestMapping注解声明这个控制器处理请求的基本路径。
@RequestMapping("/admin/common")
// 使用@Api注解指定这个控制器是Swagger文档中的一个API并提供API的描述。
@Api("通用接口")
// 使用@Slf4j注解自动为这个类注入一个日志对象方便记录日志信息。
@Slf4j
public class CommonController {
// 使用@Autowired注解自动注入CommonService服务。
@Autowired
// 定义CommonService类型的变量commmonService注意这里有一个拼写错误应该是commonService。
CommonService commmonService;
/**
*
*
* @param file 使MultipartFile
* @return Result
*/
// 使用@ApiOperation注解为Swagger文档提供文件上传操作的描述。
@ApiOperation("文件上传")
// 使用@PostMapping注解指定这个方法处理POST请求。
@PostMapping("/upload")
public Result<String> upload(MultipartFile file) {
// 记录日志信息,包括文件上传的操作和传入的文件对象。
log.info("文件上传{}", file);
// 定义一个String类型的变量filePath用于存储文件上传后的路径。
String filePath;
try {
// 调用commmonService的upload方法上传文件并返回文件路径。
filePath = commmonService.upload(file);
} catch (IOException e) {
// 如果发生IOException异常返回错误结果使用MessageConstant中的UPLOAD_FAILED常量作为错误消息。
return Result.error(MessageConstant.UPLOAD_FAILED);
}
// 如果文件上传成功,返回成功结果,包含文件路径。
return Result.success(filePath);
}
}

@ -1,186 +0,0 @@
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);
}
}

@ -1,153 +0,0 @@
// 定义包名表示该类属于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();
}
}

@ -1,134 +0,0 @@
// 定义了一个名为com.sky.controller.admin的包用于存放控制器类
package com.sky.controller.admin;
// 导入了项目中定义的结果类
import com.sky.result.Result;
// 导入了项目中定义的报告服务接口
import com.sky.service.ReportService;
// 导入了项目中定义的视图对象类
import com.sky.vo.*;
// 导入了Swagger注解用于API文档的生成
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
// 导入了Lombok提供的@Slf4j注解用于简化日志操作
import lombok.extern.slf4j.Slf4j;
// 导入了HttpServletResponse类用于处理HTTP响应
import javax.servlet.http.HttpServletResponse;
// 导入了IOException类用于处理可能发生的IO异常
import java.io.IOException;
// 导入了LocalDate类用于处理日期
import java.time.LocalDate;
// 导入了InvalidFormatException类用于处理可能发生格式无效的异常
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
/**
*
*/
// 使用@RestController注解声明这是一个控制器类并且返回的数据会自动以JSON格式响应
@RestController
// 使用@RequestMapping注解定义这个控制器类的基础请求映射路径
@RequestMapping("/admin/report")
// 使用@Slf4j注解提供日志功能
@Slf4j
// 使用@Api注解为这个控制器类添加Swagger文档的描述
@Api("营业额相关接口")
public class ReportController {
// 自动注入ReportService
@Autowired
ReportService reportService;
/**
*
*
* @param begin
* @param end
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("营业额相关接口")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/turnoverStatistics")
public Result<TurnoverReportVO> turnoverStatistics(@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin, @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end) {
// 使用日志记录营业额统计的操作
log.info("营业额统计:{},{}", begin, end);
// 调用ReportService的getTurnoverStatistics方法获取营业额统计结果
return reportService.getTurnoverStatistics(begin, end);
}
/**
*
*
* @param begin
* @param end
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("用户统计")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/userStatistics")
public Result<UserReportVO> userStatistics(@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin, @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end) {
// 使用日志记录用户统计的操作
log.info("用户统计:{},{}", begin, end);
// 调用ReportService的userStatistics方法获取用户统计结果并包装成成功的响应
return Result.success(reportService.userStatistics(begin, end));
}
/**
*
*
* @param begin
* @param end
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("订单统计")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/ordersStatistics")
public Result<OrderReportVO> orderStatistics(@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin, @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end) {
// 使用日志记录订单统计的操作
log.info("订单统计{},{}", begin, end);
// 调用ReportService的orderStatistics方法获取订单统计结果并包装成成功的响应
return Result.success(reportService.orderStatistics(begin, end));
}
/**
*
*
* @param begin
* @param end
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("销量排行前十")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/top10")
public Result<SalesTop10ReportVO> salesTop10Report(@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin, @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end) {
// 使用日志记录销量排名前十的操作
log.info("销售排名前10:{},{}", begin, end);
// 调用ReportService的salesTop10Report方法获取销量排名前十的结果并包装成成功的响应
return Result.success(reportService.salesTop10Report(begin, end));
}
/**
* excel
*
* @param httpResponse HTTP
* @return
* @throws IOException IO
* @throws InvalidFormatException
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("导出excel表格")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/export")
public Result export(HttpServletResponse httpResponse) throws IOException, InvalidFormatException {
// 使用日志记录导出Excel表格的操作
log.info("导出Excel表格");
// 调用ReportService的export方法导出Excel表格
reportService.export(httpResponse);
// 返回操作成功的结果
return Result.success("OK");
}
}

@ -1,149 +0,0 @@
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();
}
}

@ -1,94 +0,0 @@
// 定义包名表示该类属于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);
}
}

@ -1,135 +0,0 @@
// 定义了一个名为com.sky.controller.notify的包用于存放支付回调相关的控制器类
package com.sky.controller.notify;
// 导入了JSON处理相关的类
import com.alibaba.druid.support.json.JSONUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
// 导入了项目中定义的微信支付属性类
import com.sky.properties.WeChatProperties;
// 导入了项目中定义的订单服务接口
import com.sky.service.OrderService;
// 导入了微信支付加解密工具类
import com.wechat.pay.contrib.apache.httpclient.util.AesUtil;
// 导入了Lombok提供的@Slf4j注解用于简化日志操作
import lombok.extern.slf4j.Slf4j;
// 导入了HTTP相关的类
import org.apache.http.entity.ContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
/**
*
*/
// 使用@RestController注解声明这是一个控制器类并且返回的数据会自动以JSON格式响应
@RestController
// 使用@RequestMapping注解定义这个控制器类的基础请求映射路径
@RequestMapping("/notify")
// 使用@Slf4j注解提供日志功能
@Slf4j
public class PayNotifyController {
// 自动注入OrderService
@Autowired
private OrderService orderService;
// 自动注入WeChatProperties
@Autowired
private WeChatProperties weChatProperties;
/**
*
*
* @param request HTTP
* @param response HTTP
* @throws Exception
*/
@RequestMapping("/paySuccess")
public void paySuccessNotify(HttpServletRequest request, HttpServletResponse response) throws Exception {
// 读取数据
String body = readData(request);
log.info("支付成功回调:{}", body);
// 数据解密
String plainText = decryptData(body);
log.info("解密后的文本:{}", plainText);
JSONObject jsonObject = JSON.parseObject(plainText);
// 商户平台订单号
String outTradeNo = jsonObject.getString("out_trade_no");
// 微信支付交易号
String transactionId = jsonObject.getString("transaction_id");
log.info("商户平台订单号:{}", outTradeNo);
log.info("微信支付交易号:{}", transactionId);
// 业务处理,修改订单状态、来单提醒
orderService.paySuccess(outTradeNo);
// 给微信响应
responseToWeixin(response);
}
/**
* HTTP
*
* @param request HTTP
* @return
* @throws Exception
*/
private String readData(HttpServletRequest request) throws Exception {
BufferedReader reader = request.getReader();
StringBuilder result = new StringBuilder();
String line = null;
while ((line = reader.readLine()) != null) {
if (result.length() > 0) {
result.append("\n");
}
result.append(line);
}
return result.toString();
}
/**
*
*
* @param body
* @return
* @throws Exception
*/
private String decryptData(String body) throws Exception {
JSONObject resultObject = JSON.parseObject(body);
JSONObject resource = resultObject.getJSONObject("resource");
String ciphertext = resource.getString("ciphertext");
String nonce = resource.getString("nonce");
String associatedData = resource.getString("associated_data");
AesUtil aesUtil = new AesUtil(weChatProperties.getApiV3Key().getBytes(StandardCharsets.UTF_8));
// 密文解密
String plainText = aesUtil.decryptToString(associatedData.getBytes(StandardCharsets.UTF_8),
nonce.getBytes(StandardCharsets.UTF_8),
ciphertext);
return plainText;
}
/**
*
*
* @param response HTTP
* @throws Exception
*/
private void responseToWeixin(HttpServletResponse response) throws Exception{
response.setStatus(200);
HashMap<Object, Object> map = new HashMap<>();
map.put("code", "SUCCESS");
map.put("message", "SUCCESS");
response.setHeader("Content-type", ContentType.APPLICATION_JSON.toString());
response.getOutputStream().write(JSONUtils.toJSONString(map).getBytes(StandardCharsets.UTF_8));
response.flushBuffer();
}
}

@ -1,149 +0,0 @@
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("没有查询到默认地址");
}
}

@ -1,75 +0,0 @@
// 定义包名表示该类属于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);
}
}

@ -1,159 +0,0 @@
// 定义了一个名为com.sky.controller.user的包用于存放用户端订单控制器类
package com.sky.controller.user;
// 导入了项目中定义的数据传输对象DTO
import com.sky.dto.OrdersDTO;
import com.sky.dto.OrdersPageQueryDTO;
import com.sky.dto.OrdersPaymentDTO;
// 导入了项目中定义的实体类
import com.sky.entity.Orders;
// 导入了项目中定义的结果类
import com.sky.result.PageResult;
import com.sky.result.Result;
// 导入了项目中定义的服务接口
import com.sky.service.OrderService;
// 导入了项目中定义的视图对象VO
import com.sky.vo.OrderPaymentVO;
import com.sky.vo.OrderSubmitVO;
import com.sky.vo.OrderVO;
// 导入了Swagger注解用于API文档的生成
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
// 导入了Lombok提供的@Slf4j注解用于简化日志操作
import lombok.extern.slf4j.Slf4j;
// 导入了Spring框架中的@Autowired注解用于自动注入Spring管理的Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入了Spring框架中的@RequestMapping注解用于定义请求映射
import org.springframework.web.bind.annotation.*;
/**
*
*/
// 使用@RestController注解声明这是一个控制器类并且返回的数据会自动以JSON格式响应
@RestController
// 使用@RequestMapping注解定义这个控制器类的基础请求映射路径
@RequestMapping("/user/order")
// 使用@Slf4j注解提供日志功能
@Slf4j
// 使用@Api注解为这个控制器类添加Swagger文档的描述
@Api(tags = "C端-订单接口")
public class OrderController {
// 自动注入OrderService
@Autowired
OrderService orderService;
/**
*
*
* @param id ID
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("再来一单")
// 使用@PostMapping注解定义POST请求映射
@PostMapping("/repetition/{id}")
public Result repetition(@PathVariable Long id) {
orderService.repetition(id);
return Result.success();
}
/**
*
*
* @param id ID
* @return
* @throws Exception
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("取消订单")
// 使用@PutMapping注解定义PUT请求映射
@PutMapping("/cancel/{id}")
public Result cancel(@PathVariable("id") Long id) throws Exception {
orderService.userCancelById(id);
return Result.success();
}
/**
*
*
* @param ordersDTO
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("用户下单")
// 使用@RequestMapping注解定义请求映射
@RequestMapping("/submit")
public Result<OrderSubmitVO> submitOrder(@RequestBody OrdersDTO ordersDTO) {
log.info("用户下单,订单信息:{}", ordersDTO);
OrderSubmitVO order = orderService.submit(ordersDTO);
return Result.success(order);
}
/**
*
*
* @param ordersPaymentDTO
* @return
* @throws Exception
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("订单支付")
// 使用@PutMapping注解定义PUT请求映射
@PutMapping("/payment")
public Result<OrderPaymentVO> payment(@RequestBody OrdersPaymentDTO ordersPaymentDTO) throws Exception {
log.info("订单支付:{}", ordersPaymentDTO);
orderService.paySuccess(ordersPaymentDTO.getOrderNumber());
return Result.success();
}
/**
*
*
* @param id ID
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("催单")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/reminder/{id}")
public Result reminder(@PathVariable Long id) {
log.info("用户催单orderId:{}", id);
orderService.reminder(id);
return Result.success();
}
/**
*
*
* @param page
* @param pageSize
* @param status
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("历史订单查询")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/historyOrders")
public Result<PageResult> page(int page, int pageSize, Integer status) {
PageResult pageResult = orderService.pageQuery4User(page, pageSize, status);
return Result.success(pageResult);
}
/**
*
*
* @param id ID
* @return
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("查询订单详情")
// 使用@GetMapping注解定义GET请求映射
@GetMapping("/orderDetail/{id}")
public Result<OrderVO> details(@PathVariable("id") Long id) {
OrderVO orderVO = orderService.details(id);
return Result.success(orderVO);
}
}

@ -1,81 +0,0 @@
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);
}
}

@ -1,99 +0,0 @@
// 定义包名表示该类属于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();
}
}

@ -1,80 +0,0 @@
// 定义了一个名为com.sky.controller.user的包用于存放用户控制器类
package com.sky.controller.user;
// 导入了项目中定义的常量类
import com.sky.constant.JwtClaimsConstant;
// 导入了项目中定义的用户登录数据传输对象DTO
import com.sky.dto.UserLoginDTO;
// 导入了项目中定义的实体类
import com.sky.entity.User;
// 导入了项目中定义的JWT属性类
import com.sky.properties.JwtProperties;
// 导入了项目中定义的结果类
import com.sky.result.Result;
// 导入了项目中定义的服务接口
import com.sky.service.UserService;
// 导入了项目中定义的JWT工具类
import com.sky.utils.JwtUtil;
// 导入了项目中定义的视图对象VO
import com.sky.vo.UserLoginVO;
// 导入了Swagger注解用于API文档的生成
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
// 导入了Lombok提供的@Slf4j注解用于简化日志操作
import lombok.extern.slf4j.Slf4j;
// 导入了Spring框架中的@Autowired注解用于自动注入Spring管理的Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入了Spring框架中的@RequestMapping注解用于定义请求映射
import org.springframework.web.bind.annotation.*;
/**
*
*/
// 使用@RestController注解声明这是一个控制器类并且返回的数据会自动以JSON格式响应
@RestController
// 使用@RequestMapping注解定义这个控制器类的基础请求映射路径
@RequestMapping("/user/user")
// 使用@Slf4j注解提供日志功能
@Slf4j
// 使用@Api注解为这个控制器类添加Swagger文档的描述
@Api("C端用户相关接口")
public class UserController {
// 自动注入UserService
@Autowired
UserService userService;
// 自动注入JwtProperties
@Autowired
JwtProperties jwtProperties;
/**
*
*
* @param userLoginDTO
* @return JWT
*/
// 使用@ApiOperation注解为这个接口方法添加Swagger文档的描述
@ApiOperation("用户登录")
// 使用@PostMapping注解定义POST请求映射
@PostMapping("/login")
public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO){
// 使用日志记录用户登录的操作
log.info("微信登录:{}",userLoginDTO);
// 调用UserService的wxLogin方法进行微信登录
User user = userService.wxLogin(userLoginDTO);
// 生成JWT令牌
Map<String, Object> claims = new HashMap<>();
claims.put(JwtClaimsConstant.USER_ID, user.getId());
String jwt = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);
// 构建用户登录视图对象
UserLoginVO userLoginVO = UserLoginVO.builder()
.id(user.getId())
.token(jwt)
.openid(user.getOpenid())
.build();
// 返回成功的结果,包含用户登录视图对象
return Result.success(userLoginVO);
}
}

@ -1,61 +0,0 @@
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);
}
}

@ -1,68 +0,0 @@
// 定义包名表示该类属于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;
}
}
}

@ -1,71 +0,0 @@
// 定义了一个名为com.sky.mapper的包用于存放MyBatis Mapper接口
package com.sky.mapper;
// 导入了项目中定义的AddressBook实体类
import com.sky.entity.AddressBook;
// 导入了MyBatis相关注解
import org.apache.ibatis.annotations.*;
// 导入了Java.util.List接口用于定义返回列表类型
import java.util.List;
// 使用@Mapper注解标记这是一个MyBatis Mapper接口
@Mapper
public interface AddressBookMapper {
/**
* AddressBook簿
*
* @param addressBook
* @return AddressBook
*/
List<AddressBook> list(AddressBook addressBook);
/**
* 簿
*
* @param addressBook AddressBook
*/
// 使用@Insert注解标记这是一个插入操作并提供SQL语句
@Insert("insert into address_book" +
" (user_id, consignee, phone, sex, province_code, province_name, city_code, city_name, district_code," +
" district_name, detail, label, is_default)" +
" values (#{userId}, #{consignee}, #{phone}, #{sex}, #{provinceCode}, #{provinceName}, #{cityCode}, #{cityName}," +
" #{districtCode}, #{districtName}, #{detail}, #{label}, #{isDefault})")
void insert(AddressBook addressBook);
/**
* idID簿
*
* @param id ID
* @return AddressBook
*/
// 使用@Select注解标记这是一个查询操作并提供SQL语句
@Select("select * from address_book where user_id = #{id}")
AddressBook getById(Long id);
/**
* idAddressBook簿
*
* @param addressBook AddressBook
*/
void update(AddressBook addressBook);
/**
* idID
*
* @param addressBook IDAddressBook
*/
// 使用@Update注解标记这是一个更新操作并提供SQL语句
@Update("update address_book set is_default = #{isDefault} where user_id = #{userId}")
void updateIsDefaultByUserId(AddressBook addressBook);
/**
* idID簿
*
* @param id 簿ID
*/
// 使用@Delete注解标记这是一个删除操作并提供SQL语句
@Delete("delete from address_book where id = #{id}")
void deleteById(Long id);
}

@ -1,78 +0,0 @@
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);
}

@ -1,59 +0,0 @@
// 定义包名表示该类属于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);
}

@ -1,35 +0,0 @@
// 定义了一个名为com.sky.mapper的包用于存放MyBatis Mapper接口
package com.sky.mapper;
// 导入了项目中定义的OrderDetail实体类
import com.sky.entity.OrderDetail;
// 导入了MyBatis相关注解
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
// 导入了Java.util.List接口用于定义返回列表类型
import java.util.List;
// 导入了Java.util.ArrayList类用于定义批量插入的数据类型
import java.util.ArrayList;
// 使用@Mapper注解标记这是一个MyBatis Mapper接口
@Mapper
public interface OrderDetailMapper {
/**
*
*
* @param orderDetails
*/
// 此方法的具体实现需要在MyBatis的映射文件中定义通常使用<insert>标签并设置typeHandler进行批量插入
void insertBatch(ArrayList<OrderDetail> orderDetails);
/**
* idID
*
* @param orderId ID
* @return
*/
// 使用@Select注解标记这是一个查询操作并提供SQL语句
@Select("select * from order_detail where order_id = #{orderId}")
List<OrderDetail> getByOrderId(Long orderId);
}

@ -1,125 +0,0 @@
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);
}

@ -1,116 +0,0 @@
// 定义包名表示该类属于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);
}

@ -1,57 +0,0 @@
// 定义了一个名为com.sky.mapper的包用于存放MyBatis Mapper接口
package com.sky.mapper;
// 导入了项目中定义的ShoppingCart实体类
import com.sky.entity.ShoppingCart;
// 导入了MyBatis相关注解
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Update;
// 导入了Java.util.List接口用于定义返回列表类型
import java.util.List;
// 使用@Mapper注解标记这是一个MyBatis Mapper接口
@Mapper
public interface ShoppingCartMapper {
/**
*
*
* @param shoppingCartList
*/
void insertBatch(List<ShoppingCart> shoppingCartList);
/**
* ShoppingCart
*
* @param shoppingCart
* @return ShoppingCart
*/
List<ShoppingCart> list(ShoppingCart shoppingCart);
/**
* id
*
* @param shoppingCart ShoppingCart
*/
// 使用@Update注解标记这是一个更新操作并提供SQL语句
@Update("update shopping_cart set number=#{number},amount=#{amount} where id=#{id}")
void update(ShoppingCart shoppingCart);
/**
*
*
* @param shoppingCart ShoppingCart
*/
// 使用@Insert注解标记这是一个插入操作并提供SQL语句
@Insert("insert into shopping_cart(name,user_id,dish_id,setmeal_id,dish_flavor,number,amount,image,create_time)" +
"values (#{name},#{userId},#{dishId},#{setmealId},#{dishFlavor},#{number},#{amount},#{image},#{createTime})")
void insert(ShoppingCart shoppingCart);
/**
* ShoppingCart
*
* @param shoppingCart ShoppingCart
*/
void delete(ShoppingCart shoppingCart);
}

@ -1,59 +0,0 @@
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);
}

@ -1,63 +0,0 @@
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);
}

@ -1,25 +0,0 @@
// 定义一个名为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;
}

@ -1,87 +0,0 @@
package com.sky.service;
import com.sky.dto.DishDTO;
import com.sky.dto.DishPageQueryDTO;
import com.sky.entity.Dish;
import com.sky.result.PageResult;
import com.sky.vo.DishVO;
import com.sky.vo.SetmealVO;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
/**
* DishService
*/
public interface DishService {
/**
*
* DishPageQueryDTO
*
* @param dishPageQueryDTO DTO
* @return PageResult
*/
PageResult pageQuery(DishPageQueryDTO dishPageQueryDTO);
/**
*
* DishDTO
*
* @param dishDTO DTO
*/
void saveWithFlaver(DishDTO dishDTO);
/**
*
* ID
*
* @param ids ID
*/
void deleteBatch(ArrayList<Long> ids);
/**
*
* DishDTO
*
* @param dishDTO DTO
*/
void updateDish(DishDTO dishDTO);
/**
* id
* IDVO
*
* @param id ID
* @return DishVO
*/
DishVO getById(Long id);
/**
* id
* ID
*
* @param categoryId ID
* @return
*/
ArrayList<Dish> getByCategoryId(Long categoryId);
/**
*
* ID
*
* @param id ID
* @param status
*/
void startOrStop(Long id, Integer status);
/**
*
* DishVO
*
* @param dish Dish
* @return VO
*/
List<DishVO> listWithFlavor(Dish dish);
}

@ -1,70 +0,0 @@
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);
}

@ -1,66 +0,0 @@
// 定义一个名为com.sky.service的包用于存放服务相关的类和接口
package com.sky.service;
// 导入com.sky.result.Result类用于封装方法的返回结果
import com.sky.result.Result;
// 导入com.sky.vo包下的各种VOValue Object这些类用于封装数据传输对象
import com.sky.vo.*;
// 导入org.apache.http.HttpResponse类用于处理HTTP响应
import org.apache.http.HttpResponse;
// 导入org.apache.poi.openxml4j.exceptions.InvalidFormatException类用于处理Excel文件格式无效的异常
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import javax.servlet.http.HttpServletResponse; // 导入HttpServletResponse类用于处理HTTP响应
import java.io.FileNotFoundException; // 导入FileNotFoundException类用于处理文件未找到的异常
import java.io.IOException; // 导入IOException类用于处理IO异常
import java.time.LocalDate; // 导入LocalDate类用于表示没有时间的日期
import java.time.LocalDateTime; // 导入LocalDateTime类用于表示日期和时间
// 声明一个名为ReportService的接口
public interface ReportService {
/**
*
*
* @param begin LocalDate
* @param end LocalDate
* @return ResultTurnoverReportVOVO
*/
Result<TurnoverReportVO> getTurnoverStatistics(LocalDate begin, LocalDate end);
/**
*
*
* @param begin LocalDate
* @param end LocalDate
* @return UserReportVO
*/
UserReportVO userStatistics(LocalDate begin, LocalDate end);
/**
*
*
* @param begin LocalDate
* @param end LocalDate
* @return OrderReportVO
*/
OrderReportVO orderStatistics(LocalDate begin, LocalDate end);
/**
*
*
* @param begin LocalDate
* @param end LocalDate
* @return SalesTop10ReportVO
*/
SalesTop10ReportVO salesTop10Report(LocalDate begin, LocalDate end);
/**
* excel
*
* @param httpResponse HttpServletResponseExcelHTTP便
* @throws IOException IOIOException
* @throws InvalidFormatException ExcelInvalidFormatException
*/
void export(HttpServletResponse httpResponse) throws IOException, InvalidFormatException;
}

@ -1,87 +0,0 @@
package com.sky.service;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.dto.SetmealDTO;
import com.sky.dto.SetmealPageQueryDTO;
import com.sky.entity.Setmeal;
import com.sky.result.PageResult;
import com.sky.vo.DishItemVO;
import com.sky.vo.SetmealVO;
import java.util.ArrayList;
import java.util.List;
/**
* SetmealService
*/
public interface SetmealService {
/**
*
* Setmeal
*
* @param setmeal Setmeal
* @return
*/
List<Setmeal> list(Setmeal setmeal);
/**
* id
* IDVO
*
* @param id ID
* @return VO
*/
List<DishItemVO> getDishItemById(Long id);
/**
*
* SetmealPageQueryDTO
*
* @param setmealPageQueryDTO DTO
* @return PageResult
*/
PageResult pageQuery(SetmealPageQueryDTO setmealPageQueryDTO);
/**
*
* ID
*
* @param status
* @param id ID
*/
void startOrStop(Integer status, Long id);
/**
*
* SetmealDTO
*
* @param setmealDTO DTO
*/
void updateSetmeal(SetmealDTO setmealDTO);
/**
* id
* IDVO
*
* @param id ID
* @return SetmealVO
*/
SetmealVO getDishById(Long id);
/**
* id
* ID
*
* @param ids ID
*/
void batchDeleteById(ArrayList<Long> ids);
/**
*
* SetmealDTO
*
* @param setmealDTO DTO
*/
void insert(SetmealDTO setmealDTO);
}

@ -1,43 +0,0 @@
package com.sky.service;
import com.sky.dto.ShoppingCartDTO;
import com.sky.entity.ShoppingCart;
import java.util.List;
/**
* ShoppingCartServiceShoppingCart
* 使
* 便
*/
public interface ShoppingCartService {
/**
* ShoppingCartDTOidid
*
*
* @param shoppingCartDTO idid
*/
void add(ShoppingCartDTO shoppingCartDTO);
/**
* id
* List<ShoppingCart>ShoppingCartid便使
*
* @return List<ShoppingCart>ShoppingCart
*/
List<ShoppingCart> list();
/**
* ShoppingCartDTOidid
*
*
* @param shoppingCartDTO idid
*/
void delete(ShoppingCartDTO shoppingCartDTO);
/**
* id
* 便
*/
void clean();
}

@ -1,48 +0,0 @@
// 定义一个名为com.sky.service的包用于存放服务相关的类和接口
package com.sky.service;
// 导入com.sky.vo包下的BusinessDataVO类用于封装业务数据
import com.sky.vo.BusinessDataVO;
// 导入com.sky.vo包下的DishOverViewVO类用于封装菜品总览数据
import com.sky.vo.DishOverViewVO;
// 导入com.sky.vo包下的OrderOverViewVO类用于封装订单总览数据
import com.sky.vo.OrderOverViewVO;
// 导入com.sky.vo包下的SetmealOverViewVO类用于封装套餐总览数据
import com.sky.vo.SetmealOverViewVO;
// 导入java.time.LocalDateTime类用于表示日期和时间
import java.time.LocalDateTime;
// 声明一个名为WorkspaceService的接口
public interface WorkspaceService {
/**
*
*
* @param begin LocalDateTime
* @param end LocalDateTime
* @return BusinessDataVO
*/
BusinessDataVO getBusinessData(LocalDateTime begin, LocalDateTime end);
/**
*
*
* @return OrderOverViewVO
*/
OrderOverViewVO getOrderOverView();
/**
*
*
* @return DishOverViewVO
*/
DishOverViewVO getDishOverView();
/**
*
*
* @return SetmealOverViewVO
*/
SetmealOverViewVO getSetmealOverView();
}

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

Loading…
Cancel
Save