Compare commits

...

33 Commits

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

@ -0,0 +1,10 @@
<?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>

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$" />
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

@ -1,14 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<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">
<component name="ProjectRootManager">
<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/cangqiong-takeout-master.iml" filepath="$PROJECT_DIR$/.idea/cangqiong-takeout-master.iml" />
<module fileurl="file://$PROJECT_DIR$/.idea/homework.iml" filepath="$PROJECT_DIR$/.idea/homework.iml" />
</modules>
</component>
</project>

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

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

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

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

@ -0,0 +1,103 @@
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 = "订单不存在";
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -0,0 +1,29 @@
// 导入所需的包
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;
}

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

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

@ -0,0 +1,28 @@
// 导入所需的包
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;
}

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

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

@ -0,0 +1,21 @@
// 导入所需的包
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;
}

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

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

@ -0,0 +1,31 @@
// 导入所需的包
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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -0,0 +1,40 @@
// 定义了一个名为com.sky.vo的包用于存放视图对象类
package com.sky.vo;
// 导入了Lombok库中的注解用于简化类的编写
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;
}

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

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

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

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

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

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

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

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

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

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

@ -0,0 +1,35 @@
// 导入所需的包
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;
}
}

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

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

@ -0,0 +1,68 @@
// 导入所需的包
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);
}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading…
Cancel
Save