pzobk9anl
/
fresh
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

注释 #3

Merged
pzobk9anl merged 3 commits from lzh into qwer 1 month ago
Conversation 0 Commits 3 Files Changed 33
33 changed files with 1150 additions and 643 deletions
Show Stats Download Patch File Download Diff File

11
src/main/java/com/xmomen/module/receipt/controller/ReceivingCodeRequestController.java
Unescape View File

@ -19,12 +19,10 @@ import com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper;
public class ReceivingCodeRequestController {
@Autowired
MybatisDao mybatisDao;
/**
* 查询收货码请求
* @param id
* @return
*/
/*
查询收货码请求
*/
@RequestMapping(value = "/receivingCodeRequest", method = RequestMethod.GET)
@Log(actionName = "查询收货码请求")
public Page<TbReceivingCodeRequest> getExpressList(@RequestParam(value = "limit") Integer limit,
@ -38,6 +36,7 @@ public class ReceivingCodeRequestController {
map.put("keyword", keyword);
map.put("requestTimeStart", requestTimeStart);
map.put("requestTimeEnd", requestTimeEnd);
// 调用mybatisDao的selectPage方法，传入ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList"作为参数，map作为参数，limit和offset作为参数
return (Page<TbReceivingCodeRequest>) mybatisDao.selectPage(ReceivingCodeRequestMapper.ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList", map, limit, offset);
}

49
src/main/java/com/xmomen/module/receipt/controller/ReturnOrderController.java
Unescape View File

@ -22,9 +22,7 @@ import com.xmomen.module.receipt.model.ReturnOrderModel;
import com.xmomen.module.receipt.model.ReturnOrderQuery;
import com.xmomen.module.receipt.service.ReturnOrderService;
/**
* Created by Jeng on 2016/3/30.
*/
@RestController
public class ReturnOrderController {
@ -34,13 +32,8 @@ public class ReturnOrderController {
@Autowired
MybatisDao mybatisDao;
/**
* 退货订单列表
* @param limit
* @param offset
* @param keyword
* @return
*/
// 查询退货订单列表
@RequestMapping(value = "/returnOrder", method = RequestMethod.GET)
@Log(actionName = "查询退货订单列表")
public Page<ReturnOrderModel> getUserList(@RequestParam(value = "limit") Integer limit,
@ -50,29 +43,22 @@ public class ReturnOrderController {
@RequestParam(value = "returnTimeStart",required = false) String returnTimeStart,
@RequestParam(value = "returnTimeEnd",required = false) String returnTimeEnd
){
// 创建退货订单查询对象
ReturnOrderQuery orderQuery = new ReturnOrderQuery();
orderQuery.setKeyword(keyword);
// 如果退货时间开始不为空，则设置退货时间开始
if(StringUtilsExt.isNotBlank(returnTimeStart)){
orderQuery.setReturnTimeStart(returnTimeStart);
}
// 如果退货时间结束不为空，则设置退货时间结束
if(StringUtilsExt.isNotBlank(returnTimeEnd)){
orderQuery.setReturnTimeEnd(returnTimeEnd);
}
//客服经理过滤 如果有客服组权限则不过滤
// if(SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_MANAGER_PERMISSION_CODE) && !SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_PERMISSION_CODE)){
// Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
// orderQuery.setCreateUserId(userId);
// }
}
// 调用退货订单服务，获取退货订单列表
return returnOrderService.getReturnOrderList(orderQuery, limit, offset);
}
/**
* 查询退货订单商品列表
* @param limit
* @param offset
* @param orderNo
* @return
*/
@RequestMapping(value = "/returnOrder/{id}/item", method = RequestMethod.GET)
@Log(actionName = "查询退货订单商品列表")
public Page<TbReturnOrderItem> getUserList(@RequestParam(value = "limit") Integer limit,
@ -83,12 +69,7 @@ public class ReturnOrderController {
return mybatisDao.selectPageByModel(returnOrderItem, limit, offset);
}
/**
* 审核退货订单
* @param orderNo
* @param statusCd
* @return
*/
@RequestMapping(value = "/returnOrder/{id}/audit", method = RequestMethod.POST)
@Log(actionName = "审核退货订单")
public void auditReturnOrder(@PathVariable(value = "id") Integer id,
@ -96,20 +77,16 @@ public class ReturnOrderController {
this.returnOrderService.auditReturnOrder(id,statusCd);
}
/**
* 退货收货扫描操作
* @param boxNo 箱号
*/
// 调用退货订单服务，审核退货订单
@RequestMapping(value ="/returnOrder/returnOrderShouhuo",method = RequestMethod.PUT)
@Log(actionName = "退货收货扫描操作")
public ReturnOrderModel returnOrderShouhuo(@RequestParam(value = "boxNo")String boxNo){
return this.returnOrderService.returnOrderShouhuo(boxNo);
}
/**
* 退货收货操作
* @param boxNo 箱号
*/
// 调用退货订单服务，退货收货扫描操作
@RequestMapping(value ="/returnOrder/shouhuo",method = RequestMethod.PUT)
@Log(actionName = "退货收货操作")
public void orderNo(@RequestParam(value = "orderNo")String orderNo){

29
src/main/java/com/xmomen/module/receipt/entity/TbReceivingCodeRequest.java
Unescape View File

@ -12,34 +12,27 @@ import javax.persistence.Version;
@Entity
@Table(name = "tb_receiving_code_request")
public class TbReceivingCodeRequest extends BaseMybatisModel {
/**
* 主键
*/
// 主键ID
private Integer id;
/**
* 订单号
*/
// 订单号
private String orderNo;
/**
* 请求人
*/
// 请求用户
private String requestUser;
/**
* 请求时间
*/
// 请求时间
private Date requestTime;
/**
* 请求人手机号
*/
// 请求电话
private String requestPhone;
/**
* 请求人所属快递商
*/
// 请求快递ID
private Integer requestExpressId;
@Column(name = "id")

97
src/main/java/com/xmomen/module/receipt/entity/TbReceivingCodeRequestExample.java
Unescape View File

@ -5,47 +5,60 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
// 定义一个名为TbReceivingCodeRequestExample的类，继承自BaseMybatisExample
public class TbReceivingCodeRequestExample extends BaseMybatisExample {
// 定义一个orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量，用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria
public TbReceivingCodeRequestExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置orderByClause的值
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取orderByClause的值
public String getOrderByClause() {
return orderByClause;
}
// 设置distinct的值
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取distinct的值
public boolean isDistinct() {
return distinct;
}
// 获取oredCriteria的值
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加一个查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -54,37 +67,46 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
return criteria;
}
// 创建一个查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空查询条件
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 定义一个内部类GeneratedCriteria，用于存储查询条件
protected abstract static class GeneratedCriteria {
// 定义一个criteria变量，用于存储查询条件
protected List<Criterion> criteria;
// 构造函数，初始化criteria
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
// 判断查询条件是否有效
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加一个查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -92,6 +114,7 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -99,6 +122,7 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -106,366 +130,439 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 判断id是否为空
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
// 判断id是否不为空
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
// 判断id是否等于某个值
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
// 判断id是否不等于某个值
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
// 判断id是否大于某个值
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
// 判断id是否大于等于某个值
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
// 判断id是否小于某个值
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
// 判断id是否小于等于某个值
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
// 判断id是否在某个范围内
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
// 判断id是否不在某个范围内
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
// 判断id是否在某个范围内
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
// 判断id是否不在某个范围内
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 判断orderNo是否为空
public Criteria andOrderNoIsNull() {
addCriterion("order_no is null");
return (Criteria) this;
}
// 判断orderNo是否不为空
public Criteria andOrderNoIsNotNull() {
addCriterion("order_no is not null");
return (Criteria) this;
}
// 判断orderNo是否等于某个值
public Criteria andOrderNoEqualTo(String value) {
addCriterion("order_no =", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不等于某个值
public Criteria andOrderNoNotEqualTo(String value) {
addCriterion("order_no <>", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否大于某个值
public Criteria andOrderNoGreaterThan(String value) {
addCriterion("order_no >", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否大于等于某个值
public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
addCriterion("order_no >=", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否小于某个值
public Criteria andOrderNoLessThan(String value) {
addCriterion("order_no <", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否小于等于某个值
public Criteria andOrderNoLessThanOrEqualTo(String value) {
addCriterion("order_no <=", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否包含某个值
public Criteria andOrderNoLike(String value) {
addCriterion("order_no like", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不包含某个值
public Criteria andOrderNoNotLike(String value) {
addCriterion("order_no not like", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否在某个范围内
public Criteria andOrderNoIn(List<String> values) {
addCriterion("order_no in", values, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不在某个范围内
public Criteria andOrderNoNotIn(List<String> values) {
addCriterion("order_no not in", values, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否在某个范围内
public Criteria andOrderNoBetween(String value1, String value2) {
addCriterion("order_no between", value1, value2, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不在某个范围内
public Criteria andOrderNoNotBetween(String value1, String value2) {
addCriterion("order_no not between", value1, value2, "orderNo");
return (Criteria) this;
}
// 判断requestUser是否为空
public Criteria andRequestUserIsNull() {
addCriterion("request_user is null");
return (Criteria) this;
}
// 判断requestUser是否不为空
public Criteria andRequestUserIsNotNull() {
addCriterion("request_user is not null");
return (Criteria) this;
}
// 判断requestUser是否等于某个值
public Criteria andRequestUserEqualTo(String value) {
addCriterion("request_user =", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不等于某个值
public Criteria andRequestUserNotEqualTo(String value) {
addCriterion("request_user <>", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否大于某个值
public Criteria andRequestUserGreaterThan(String value) {
addCriterion("request_user >", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否大于等于某个值
public Criteria andRequestUserGreaterThanOrEqualTo(String value) {
addCriterion("request_user >=", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否小于某个值
public Criteria andRequestUserLessThan(String value) {
addCriterion("request_user <", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否小于等于某个值
public Criteria andRequestUserLessThanOrEqualTo(String value) {
addCriterion("request_user <=", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否包含某个值
public Criteria andRequestUserLike(String value) {
addCriterion("request_user like", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不包含某个值
public Criteria andRequestUserNotLike(String value) {
addCriterion("request_user not like", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否在某个范围内
public Criteria andRequestUserIn(List<String> values) {
addCriterion("request_user in", values, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不在某个范围内
public Criteria andRequestUserNotIn(List<String> values) {
addCriterion("request_user not in", values, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否在某个范围内
public Criteria andRequestUserBetween(String value1, String value2) {
addCriterion("request_user between", value1, value2, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不在某个范围内
public Criteria andRequestUserNotBetween(String value1, String value2) {
addCriterion("request_user not between", value1, value2, "requestUser");
return (Criteria) this;
}
// 判断requestTime是否为空
public Criteria andRequestTimeIsNull() {
addCriterion("request_time is null");
return (Criteria) this;
}
// 判断requestTime是否不为空
public Criteria andRequestTimeIsNotNull() {
addCriterion("request_time is not null");
return (Criteria) this;
}
// 判断requestTime是否等于某个值
public Criteria andRequestTimeEqualTo(Date value) {
addCriterion("request_time =", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否不等于某个值
public Criteria andRequestTimeNotEqualTo(Date value) {
addCriterion("request_time <>", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否大于某个值
public Criteria andRequestTimeGreaterThan(Date value) {
addCriterion("request_time >", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否大于等于某个值
public Criteria andRequestTimeGreaterThanOrEqualTo(Date value) {
addCriterion("request_time >=", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否小于某个值
public Criteria andRequestTimeLessThan(Date value) {
addCriterion("request_time <", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否小于等于某个值
public Criteria andRequestTimeLessThanOrEqualTo(Date value) {
addCriterion("request_time <=", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否在某个范围内
public Criteria andRequestTimeIn(List<Date> values) {
addCriterion("request_time in", values, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否不在某个范围内
public Criteria andRequestTimeNotIn(List<Date> values) {
addCriterion("request_time not in", values, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否在某个范围内
public Criteria andRequestTimeBetween(Date value1, Date value2) {
addCriterion("request_time between", value1, value2, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否不在某个范围内
public Criteria andRequestTimeNotBetween(Date value1, Date value2) {
addCriterion("request_time not between", value1, value2, "requestTime");
return (Criteria) this;
}
// 判断requestPhone是否为空
public Criteria andRequestPhoneIsNull() {
addCriterion("request_phone is null");
return (Criteria) this;
}
// 判断requestPhone是否不为空
public Criteria andRequestPhoneIsNotNull() {
addCriterion("request_phone is not null");
return (Criteria) this;
}
// 判断requestPhone是否等于某个值
public Criteria andRequestPhoneEqualTo(String value) {
addCriterion("request_phone =", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不等于某个值
public Criteria andRequestPhoneNotEqualTo(String value) {
addCriterion("request_phone <>", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否大于某个值
public Criteria andRequestPhoneGreaterThan(String value) {
addCriterion("request_phone >", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否大于等于某个值
public Criteria andRequestPhoneGreaterThanOrEqualTo(String value) {
addCriterion("request_phone >=", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否小于某个值
public Criteria andRequestPhoneLessThan(String value) {
addCriterion("request_phone <", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否小于等于某个值
public Criteria andRequestPhoneLessThanOrEqualTo(String value) {
addCriterion("request_phone <=", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否包含某个值
public Criteria andRequestPhoneLike(String value) {
addCriterion("request_phone like", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不包含某个值
public Criteria andRequestPhoneNotLike(String value) {
addCriterion("request_phone not like", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否在某个范围内
public Criteria andRequestPhoneIn(List<String> values) {
addCriterion("request_phone in", values, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不在某个范围内
public Criteria andRequestPhoneNotIn(List<String> values) {
addCriterion("request_phone not in", values, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否在某个范围内
public Criteria andRequestPhoneBetween(String value1, String value2) {
addCriterion("request_phone between", value1, value2, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不在某个范围内
public Criteria andRequestPhoneNotBetween(String value1, String value2) {
addCriterion("request_phone not between", value1, value2, "requestPhone");
return (Criteria) this;
}
// 判断requestExpressId是否为空
public Criteria andRequestExpressIdIsNull() {
addCriterion("request_express_id is null");
return (Criteria) this;
}
// 判断requestExpressId是否不为空
public Criteria andRequestExpressIdIsNotNull() {
addCriterion("request_express_id is not null");
return (Criteria) this;
}
// 判断requestExpressId是否等于某个值
public Criteria andRequestExpressIdEqualTo(Integer value) {
addCriterion("request_express_id =", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否不等于某个值
public Criteria andRequestExpressIdNotEqualTo(Integer value) {
addCriterion("request_express_id <>", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否大于某个值
public Criteria andRequestExpressIdGreaterThan(Integer value) {
addCriterion("request_express_id >", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否大于等于某个值
public Criteria andRequestExpressIdGreaterThanOrEqualTo(Integer value) {
addCriterion("request_express_id >=", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否小于某个值
public Criteria andRequestExpressIdLessThan(Integer value) {
addCriterion("request_express_id <", value, "requestExpressId");
return (Criteria) this;

5
src/main/java/com/xmomen/module/receipt/entity/mapper/TbReceivingCodeRequestMapper.java
Unescape View File

@ -5,12 +5,17 @@ import com.xmomen.module.receipt.entity.TbReceivingCodeRequest;
import com.xmomen.module.receipt.entity.TbReceivingCodeRequestExample;
import org.apache.ibatis.annotations.Param;
// TbReceivingCodeRequestMapper接口，继承MybatisMapper
public interface TbReceivingCodeRequestMapper extends MybatisMapper {
// 根据example统计TbReceivingCodeRequest的数量
int countByExample(TbReceivingCodeRequestExample example);
// 根据example删除TbReceivingCodeRequest
int deleteByExample(TbReceivingCodeRequestExample example);
// 插入TbReceivingCodeRequest
int insertSelective(TbReceivingCodeRequest record);
// 根据example更新TbReceivingCodeRequest
int updateByExampleSelective(@Param("record") TbReceivingCodeRequest record, @Param("example") TbReceivingCodeRequestExample example);
}

2
src/main/java/com/xmomen/module/receipt/mapper/ReceivingCodeRequestMapper.java
Unescape View File

@ -1,6 +1,8 @@
package com.xmomen.module.receipt.mapper;
// 定义一个接口ReceivingCodeRequestMapper
public interface ReceivingCodeRequestMapper {
// 定义一个常量ReceivingCodeRequestMapperNameSpace，值为"com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper."
public static final String ReceivingCodeRequestMapperNameSpace = "com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper.";
}

3
src/main/java/com/xmomen/module/receipt/mapper/ReceivingCodeRequestMapper.xml
Unescape View File

@ -14,13 +14,16 @@
left join tb_order_ref receiving_code on receiving_code.order_no = main.order_no and receiving_code.ref_type = 'SHOU_HUO_NO'
left join tb_order tborder on tborder.order_no = main.order_no
<where>
<!-- 根据关键字查询 -->
<if test="keyword">
AND main.request_phone LIKE CONCAT('%', #{keyword}, '%')
or main.request_user LIKE CONCAT('%', #{keyword}, '%')
</if>
<!-- 根据订单号查询 -->
<if test="orderNo">
AND main.order_no LIKE CONCAT('%', #{orderNo}, '%')
</if>
<!-- 根据请求时间查询 -->
<if test="requestTimeStart">
<![CDATA[
AND DATE_FORMAT(main.request_time ,'%Y-%m-%d')>= #{requestTimeStart}

6
src/main/java/com/xmomen/module/receipt/mapper/ReturnOrderMapper.java
Unescape View File

@ -1,9 +1,9 @@
package com.xmomen.module.receipt.mapper;
/**
* Created by Jeng on 16/4/13.
*/
// 定义一个接口，用于操作退货订单
public interface ReturnOrderMapper {
// 定义一个常量，用于命名空间
public static final String RETURN_ORDER_MAPPER_NAMESPACE = "com.xmomen.module.receipt.mapper.ReturnOrderMapper.";
}

3
src/main/java/com/xmomen/module/receipt/mapper/ReturnOrderMapper.xml
Unescape View File

@ -1,8 +1,7 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xmomen.module.receipt.mapper.ReturnOrderMapper" >
<!-- 查询订单 -->
<!-- 查询退货单列表 -->
<select id="getReturnOrderList" resultType="com.xmomen.module.receipt.model.ReturnOrderModel" parameterType="com.xmomen.module.receipt.model.ReturnOrderQuery">
select
main.return_time,

39
src/main/java/com/xmomen/module/receipt/model/ReceivingCodeRequestModel.java
Unescape View File

@ -6,43 +6,32 @@ import lombok.Data;
public @Data class ReceivingCodeRequestModel {
/**
* 主键
*/
// 主键ID
private Integer id;
/**
* 订单号
*/
// 订单号
private String orderNo;
/**
* 请求人
*/
// 请求用户
private String requestUser;
/**
* 请求时间
*/
// 请求时间
private Date requestTime;
/**
* 请求人手机号
*/
// 请求电话
private String requestPhone;
/**
* 快递商名称
*/
// 快递公司名称
private String expressName;
/**
* 收货码
*/
// 收货码
private String receivingCode;
/**
* 收货人
*/
// 收货人姓名
private String consigneeName;
}

4
src/main/java/com/xmomen/module/receipt/model/ReturnItemModel.java
Unescape View File

@ -4,9 +4,13 @@ import java.io.Serializable;
import lombok.Data;
// 返回项模型类
public @Data class ReturnItemModel implements Serializable {
// 项目代码
private String itemCode;
// 项目数量
private Integer itemNumber;
// 项目名称
private String itemName;
}

191
src/main/java/com/xmomen/module/receipt/model/ReturnOrderModel.java
Unescape View File

@ -15,173 +15,130 @@ import com.xmomen.module.order.model.PackingModel;
*/
public @Data class ReturnOrderModel implements Serializable {
/**
* 订单ID
*/
// 返回订单ID
private Integer id;
/**
* 退货订单id
*/
// 订单ID
private Integer returnOrderId;
/**
* 订单类型
*/
// 订单类型
private Integer orderType;
/**
* 订单类型描述
*/
// 订单类型描述
private String orderTypeDesc;
/**
* 订单来源：1-微信订单，2-商城订单，3-客服下单，4-采摘订单
*/
// 订单来源
private Integer orderSource;
/**
* 订单来源描述
*/
// 订单来源描述
private String orderSourceDesc;
/**
* 付款方式
*/
// 支付方式
private Integer paymentMode;
/**
* 付款方式描述
*/
// 支付方式描述
private String paymentModeDesc;
/**
* 订单编码
*/
// 订单号
private String orderNo;
/**
* 订单状态
*/
// 订单状态
private String orderStatus;
/**
* 装箱任务负责人名称
*/
// 包装任务用户名
private String packingTaskUsername;
/**
* 装箱任务负责人ID
*/
// 包装任务用户ID
private Integer packingTaskUserId;
/**
* 订单装箱任务状态
*/
// 包装任务状态
private Integer packingTaskStatus;
/**
* 装箱任务状态描述
*/
// 包装任务状态描述
private String packingTaskStatusDesc;
/**
* 装箱任务分配时间
*/
// 包装任务创建时间
private Date packingTaskCreateTime;
/**
* 装箱任务开始时间
*/
// 包装任务开始时间
private Date packingTaskStartTime;
/**
* 装箱任务完成时间
*/
// 包装任务结束时间
private Date packingTaskEndTime;
/**
* 订单状态描述
*/
// 订单状态描述
private String orderStatusDesc;
/**
* 收货人手机
*/
// 收货人电话
private String consigneePhone;
/**
* 收货人姓名
*/
// 收货人姓名
private String consigneeName;
/**
* 收货人地址
*/
// 收货人地址
private String consigneeAddress;
/**
* 运送方式 1-快递，2-自提
*/
// 运输方式
private Integer transportMode;
/**
* 订单备注
*/
// 备注
private String remark;
/**
* 折扣价
*/
// 折扣价格
private BigDecimal discountPrice;
/**
* 订单总金额
*/
// 总金额
private BigDecimal totalAmount;
/**
* 订单创建时间
*/
// 创建时间
private Date createTime;
/**
* 订单创建人ID
*/
// 创建用户的ID
private Integer createUserId;
// 用户创建者
private String createUser;
/**
* 配送时间
*/
private Date appointmentTime;
/**
* 支付卡（券）号
*/
private String couponNumber;
/**
* 快递商
*/
private String expressName;
private Integer despatchExpressId;
/**
* 项目经理
*/
private String managerName;
/**
* 单位
*/
private String companyName;
private String batchNo;
/**
* 付款方式
*/
private Integer otherPaymentMode;
private String otherPaymentModeDesc;
@ -190,44 +147,44 @@ public @Data class ReturnOrderModel implements Serializable {
private String receivingCode;
// 订单项列表
private List<TbReturnOrderItem> itemList;
// 返回时间
private Date returnTime;
// 返回状态
private String returnStatus;
// 返回状态描述
private String returnStatusDesc;
/**
* 审核状态（0-不同意，1-同意）
*/
// 审核状态
private Integer auditStatus;
/**
* 审核时间
*/
// 审核日期
private Date auditDate;
/**
* 审核人
*/
// 审核用户ID
private Integer auditUserId;
// 审核用户名
private String auditUserName;
/**
* 拿货时间
*/
// 商品取货日期
private Date takeGoodsDate;
/**
* 拿货人
*/
// 用户取货ID
private Integer takeGoodsUserId;
// 商品领取人姓名
private String takeGoodsUserName;
/**
* 拿货人手机号
*/
// 顾客取货电话
private String takeGoodsPhone;
}

15
src/main/java/com/xmomen/module/receipt/model/ReturnOrderQuery.java
Unescape View File

@ -5,21 +5,32 @@ import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
*/
public @Data
class ReturnOrderQuery implements Serializable {
// 返回订单ID
private Integer id;
// 订单号
private String orderNo;
// 返回时间开始
private String returnTimeStart;
// 返回时间结束
private String returnTimeEnd;
// 关键字
private String keyword;
// 返回状态
private String returnStatus;
// 管理员ID
private String managerId;
// 收货人姓名
private String consigneeName;
// 是否无显示取消
private int hasNoShowCancel;
// 是否显示发货
private int showDespatch;
// 创建用户ID
private int createUserId;
// 发货快递ID
private int despatchExpressId;
}

324
src/main/java/com/xmomen/module/receipt/service/ReturnOrderService.java
Unescape View File

@ -1,352 +1,364 @@
package com.xmomen.module.receipt.service;
// 声明该Java类所在的包路径，com.xmomen.module.receipt.service表示该类位于名为service的包中，
// 这个包是com.xmomen.module.receipt包的子包
import java.math.BigDecimal;
// 导入用于精确的十进制运算的类
import java.util.Date;
// 导入表示日期和时间的类
import java.util.HashMap;
// 导入一种键值对存储的数据结构类
import java.util.List;
// 导入用于表示有序的元素集合的接口
import java.util.Map;
// 导入用于表示键值对的映射关系的接口
import com.xmomen.framework.exception.BusinessException;
// 导入自定义的业务异常类
import com.xmomen.module.base.entity.CdItem;
// 导入基础模块中的商品实体类
import com.xmomen.module.order.entity.*;
// 导入订单模块的所有实体类
import com.xmomen.module.stock.service.StockService;
// 导入库存服务类
import org.apache.shiro.SecurityUtils;
// 导入Apache Shiro框架中用于处理安全相关操作的工具类
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架用于自动装配依赖的注解
import org.springframework.stereotype.Service;
// 导入Spring框架用于标记服务类的注解
import org.springframework.transaction.annotation.Transactional;
// 导入Spring框架用于声明事务的注解
import com.xmomen.framework.mybatis.dao.MybatisDao;
// 导入自定义的MyBatis数据访问对象类
import com.xmomen.framework.mybatis.page.Page;
// 导入用于分页操作的类
import com.xmomen.framework.utils.AssertExt;
// 导入自定义的断言工具类
import com.xmomen.framework.utils.StringUtilsExt;
// 导入自定义的字符串工具类
import com.xmomen.module.base.constant.AppConstants;
// 导入应用程序的常量类
import com.xmomen.module.base.entity.CdExpress;
// 导入基础模块中的快递实体类
import com.xmomen.module.base.service.ItemService;
// 导入商品服务类
import com.xmomen.module.order.mapper.OrderMapper;
// 导入订单模块的Mapper接口
import com.xmomen.module.order.model.ReturnOrder;
// 导入订单模块的退货订单模型类
import com.xmomen.module.receipt.mapper.ReturnOrderMapper;
// 导入退货订单模块的Mapper接口
import com.xmomen.module.receipt.model.ReturnOrderModel;
// 导入退货订单模块的模型类
import com.xmomen.module.receipt.model.ReturnOrderQuery;
// 导入退货订单模块的查询条件类
import com.xmomen.module.wx.model.AjaxResult;
// 导入微信模块的Ajax结果模型类
/**
* Created by Jeng on 16/4/5.
*/
@Service
// 使用@Service注解将ReturnOrderService类标记为一个Spring服务类
public class ReturnOrderService {
@Autowired
// 使用@Autowired注解自动装配MybatisDao类型的对象
MybatisDao mybatisDao;
@Autowired
// 使用@Autowired注解自动装配ItemService类型的对象
ItemService itemService;
@Autowired
// 使用@Autowired注解自动装配StockService类型的对象
StockService stockService;
/**
* 查询订单
*
* @param orderQuery
* @param limit
* @param offset
* @return
*/
// 获取退货订单列表
public Page<ReturnOrderModel> getReturnOrderList(
ReturnOrderQuery orderQuery, Integer limit, Integer offset) {
// 该方法用于获取退货订单列表并进行分页，接受查询条件对象orderQuery以及分页参数limit和offset
return (Page<ReturnOrderModel>) mybatisDao.selectPage(
ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
+ "getReturnOrderList", orderQuery, limit, offset);
// 调用mybatisDao的selectPage方法，通过ReturnOrderMapper的命名空间和方法名执行查询，返回分页结果
}
/**
* 查询订单
*
* @param orderQuery
* @return
*/
// 获取退货订单列表
public List<ReturnOrderModel> getReturnOrderList(ReturnOrderQuery orderQuery) {
// 这是一个重载的方法，用于获取退货订单列表（不进行分页），接受查询条件对象orderQuery
return mybatisDao.getSqlSessionTemplate().selectList(
ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
+ "getReturnOrderList", orderQuery);
// 调用mybatisDao的getSqlSessionTemplate方法获取SqlSessionTemplate，
// 然后通过ReturnOrderMapper的命名空间和方法名执行查询，返回结果列表
}
/**
* 订单拒绝收货
*
* @param orderNo
* @param phone
* @return
*/
// 拒绝收货
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public AjaxResult noShouhuo(String orderNo, String phone, int expressId) {
// 该方法用于处理拒绝收货的业务逻辑，接受订单号orderNo、联系电话phone和快递员ID expressId，返回AjaxResult对象
AjaxResult ajaxResult = new AjaxResult();
// 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
// 判断订单状态
TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
// 创建一个TbReturnOrderExample对象用于构建查询条件
tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbReturnOrder tbReturnOrder = mybatisDao
.selectOneByExample(tbOrderExample);
// 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
if (tbReturnOrder != null) {
ajaxResult.setMessage("订单不能拒绝，请联系客服人员。");
// 如果订单已存在某种状态，设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
tbReturnOrder = new TbReturnOrder();
// 创建一个新的TbReturnOrder对象
tbReturnOrder.setOrderNo(orderNo);
// 设置订单号
// 退货运输中
tbReturnOrder.setReturnStatus(14);
// 设置退货状态为“退货运输中”（状态码14）
tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
// 设置取货日期为系统当前日期
tbReturnOrder.setTakeGoodsPhone(phone);
// 设置取货联系电话
tbReturnOrder.setTakeGoodsUserId(expressId);
// 设置取货的快递员用户ID
tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
// 设置退货时间为系统当前日期
tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
// 调用mybatisDao的insertByModel方法插入新的退货订单记录，并返回插入后的对象
TbOrderItem orderItemDb = new TbOrderItem();
// 创建一个TbOrderItem对象
orderItemDb.setOrderNo(orderNo);
// 设置订单号
List<TbOrderItem> returnOrderItems = mybatisDao
.selectByModel(orderItemDb);
// 调用mybatisDao的selectByModel方法查询该订单下的所有订单商品项
BigDecimal returnTotalAmount = BigDecimal.ZERO;
// 创建一个BigDecimal对象用于记录退货总金额，并初始化为0
for (TbOrderItem orderItem : returnOrderItems) {
// 遍历订单商品项列表
TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
// 创建一个新的TbReturnOrderItem对象
returnOrderItem.setItemCode(orderItem.getItemCode());
// 设置商品编码
returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
// 设置退货订单ID
returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
// 设置商品数量
returnOrderItem.setItemName(orderItem.getItemName());
// 设置商品名称
returnOrderItem.setIsNeed(1);
// 设置是否需要（这里值为1表示需要）
mybatisDao.insert(returnOrderItem);
// 插入退货订单商品项记录
//金额相加
returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
// 将当前商品项的金额（单价乘以数量）累加到退货总金额中
}
//退款金额
tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
// 设置退货订单的退款总金额
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
// 创建一个TbOrderExample对象用于构建查询条件
orderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbOrder order = new TbOrder();
// 创建一个新的TbOrder对象
//是拒绝收货
order.setIsReject(1);
// 设置订单为拒绝收货状态（值为1表示拒绝）
// 退货运输中
order.setOrderStatus("14");
// 设置订单状态为“退货运输中”（状态码14）
mybatisDao.updateOneByExampleSelective(order, orderExample);
// 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
ajaxResult.setMessage("订单已拒收，请及时送回仓库。");
// 设置ajaxResult的消息
ajaxResult.setResult(1);
// 设置ajaxResult的结果码为1
return ajaxResult;
// 返回ajaxResult对象
}
/**
* 订单退货
*
* @param orderNo
* @param itemIds
* @return
*/
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public AjaxResult returnOrder(String orderNo, String itemIds) {
// 该方法用于处理退货申请的业务逻辑，接受订单号orderNo和商品ID字符串itemIds，返回AjaxResult对象
AjaxResult ajaxResult = new AjaxResult();
// 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
// 判断订单状态
TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
// 创建一个TbReturnOrderExample对象用于构建查询条件
tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbReturnOrder tbReturnOrder = mybatisDao
.selectOneByExample(tbOrderExample);
// 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
if (tbReturnOrder != null) {
ajaxResult.setMessage("订单不能退货，请联系客服人员。");
// 如果订单已存在某种状态，设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
tbReturnOrder = new TbReturnOrder();
// 创建一个新的TbReturnOrder对象
tbReturnOrder.setOrderNo(orderNo);
// 设置订单号
tbReturnOrder.setReturnStatus(10);// 申请退货
// 设置退货状态为“申请退货”（状态码10）
tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
// 设置退货时间为系统当前日期
tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
// 调用mybatisDao的insertByModel方法插入新的退货订单记录，并返回插入后的对象
BigDecimal returnTotalAmount = BigDecimal.ZERO;
// 创建一个BigDecimal对象用于记录退货总金额，并初始化为0
for (String itemId : itemIds.split(",")) {
// 遍历商品ID字符串，以逗号分割
if (StringUtilsExt.isEmpty(itemId)) {
continue;
// 如果商品ID为空，跳过本次循环
}
TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
// 创建一个新的TbReturnOrderItem对象
TbOrderItem orderItem = this.mybatisDao.selectByPrimaryKey(
TbOrderItem.class, Integer.parseInt(itemId));
// 根据商品ID查询对应的订单商品项
returnOrderItem.setItemCode(orderItem.getItemCode());
// 设置商品编码
returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
// 设置退货订单ID
returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
// 设置商品数量
returnOrderItem.setItemName(orderItem.getItemName());
// 设置商品名称
returnOrderItem.setIsNeed(1);
// 设置是否需要（这里值为1表示需要）
mybatisDao.insert(returnOrderItem);
// 插入退货订单商品项记录
//金额相加
returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
// 将当前商品项的金额（单价乘以数量）累加到退货总金额中
}
//退款金额
tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
// 设置退货订单的退款总金额
mybatisDao.update(tbReturnOrder);
// 调用mybatisDao的update方法更新退货订单记录
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
// 创建一个TbOrderExample对象用于构建查询条件
orderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbOrder order = new TbOrder();
// 创建一个新的TbOrder对象
order.setOrderStatus("10");// 申请退货
// 设置订单状态为“申请退货”（状态码10）
mybatisDao.updateOneByExampleSelective(order, orderExample);
// 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
ajaxResult.setMessage("退货申请提交成功，请等待客服审核。");
// 设置ajaxResult的消息
ajaxResult.setResult(1);
// 设置ajaxResult的结果码为1
return ajaxResult;
// 返回ajaxResult对象
}
/**
* 退货订单收货
*
* @param orderNo
* @param phone
* @param expressId
* @return
*/
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public AjaxResult shouhuoReturn(String orderNo, String phone, int expressId) {
// 该方法用于处理退货收货的业务逻辑，接受订单号orderNo、联系电话phone和快递员ID expressId，返回AjaxResult对象
AjaxResult ajaxResult = new AjaxResult();
// 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
// 判断订单状态
TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
// 创建一个TbReturnOrderExample对象用于构建查询条件
tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbReturnOrder tbReturnOrder = mybatisDao
.selectOneByExample(tbOrderExample);
// 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
if (tbReturnOrder.getReturnStatus() != 11) {
ajaxResult.setMessage("订单状态不为退货中，不能收货，请联系客服人员。");
// 如果订单的退货状态不是“退货中”（状态码11），设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
tbReturnOrder.setReturnStatus(14);// 退货运输中
// 设置退货订单的状态为“退货运输中”（状态码14）
tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
// 设置取货日期为系统当前日期
tbReturnOrder.setTakeGoodsPhone(phone);
// 设置取货联系电话
tbReturnOrder.setTakeGoodsUserId(expressId);
// 设置取货的快递员用户ID
mybatisDao.update(tbReturnOrder);
// 调用mybatisDao的update方法更新退货订单记录
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
// 创建一个TbOrderExample对象用于构建查询条件
orderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbOrder order = new TbOrder();
// 创建一个新的TbOrder对象
order.setOrderStatus("14");// 退货运输中
// 设置订单状态为“退货运输中”（状态码14）
mybatisDao.updateOneByExampleSelective(order, orderExample);
// 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
ajaxResult.setMessage("退货订单收货成功，请尽快送回仓库。");
// 设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
/**
* 退货订单审核
*
* @param id
* @param statusCd
*/
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public void auditReturnOrder(int id, int statusCd) {
// 该方法用于审核退货订单，接受退货订单ID id和审核状态码statusCd
TbReturnOrder returnOrder = this.mybatisDao.selectByPrimaryKey(
TbReturnOrder.class, id);
// 根据退货订单ID查询对应的TbReturnOrder对象
returnOrder.setAuditStatus(statusCd);
// 设置审核状态
returnOrder.setAuditDate(mybatisDao.getSysdate());
// 设置审核日期为系统当前日期
if (statusCd == 1) {
// 如果审核状态码为1（表示通过审核）
// 退货中
returnOrder.setReturnStatus(11);
Integer userId = (Integer) SecurityUtils.getSubject().getSession()
.getAttribute(AppConstants.SESSION_USER_ID_KEY);
returnOrder.setAuditUserId(userId);
this.mybatisDao.save(returnOrder);
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
orderExample.createCriteria().andOrderNoEqualTo(
returnOrder.getOrderNo());
TbOrder order = new TbOrder();
// 退货中
order.setOrderStatus("11");
mybatisDao.updateOneByExampleSelective(order, orderExample);
}
else {
// 拒绝退货
returnOrder.setReturnStatus(16);
Integer userId = (Integer) SecurityUtils.getSubject().getSession()
.getAttribute(AppConstants.SESSION_USER_ID_KEY);
returnOrder.setAuditUserId(userId);
this.mybatisDao.save(returnOrder);
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
orderExample.createCriteria().andOrderNoEqualTo(
returnOrder.getOrderNo());
TbOrder order = new TbOrder();
// 拒绝退货
order.setOrderStatus("16");
mybatisDao.updateOneByExampleSelective(order, orderExample);
}
}
/**
* 退货收货操作
*
* @param boxNo 箱号
*/
@Transactional
public ReturnOrderModel returnOrderShouhuo(String boxNo) {
// 通过箱号查找订单号
TbOrderRelation tbOrderRelation = new TbOrderRelation();
tbOrderRelation.setRefType(OrderMapper.ORDER_PACKING_RELATION_CODE);
tbOrderRelation.setRefValue(boxNo);
tbOrderRelation = mybatisDao.selectOneByModel(tbOrderRelation);
AssertExt.notNull(tbOrderRelation, "扫描的箱号不存在！请确认。");
TbOrder order = new TbOrder();
order.setOrderNo(tbOrderRelation.getOrderNo());
order = mybatisDao.selectOneByModel(order);
AssertExt.notNull(order, "订单不存在！");
String orderStatus = order.getOrderStatus();
AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中，不能收货！");
TbReturnOrder returnOrder = new TbReturnOrder();
returnOrder.setOrderNo(order.getOrderNo());
returnOrder = mybatisDao.selectOneByModel(returnOrder);
ReturnOrderModel returnOrderModel = new ReturnOrderModel();
TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
returnOrderItem.setReturnOrderId(returnOrder.getId());
List<TbReturnOrderItem> returnOrderItemList = this.mybatisDao
.selectByModel(returnOrderItem);
returnOrderModel.setItemList(returnOrderItemList);
returnOrderModel.setOrderNo(order.getOrderNo());
return returnOrderModel;
}
/**
* 退货收货操作
*
* @param orderNo 箱号
*/
@Transactional
public void shouhuo(String orderNo) throws BusinessException {
TbOrder order = new TbOrder();
order.setOrderNo(orderNo);
order = mybatisDao.selectOneByModel(order);
AssertExt.notNull(order, "订单不存在！");
String orderStatus = order.getOrderStatus();
AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中，不能收货！");
order.setOrderStatus("15");
mybatisDao.update(order);
TbReturnOrder returnOrder = new TbReturnOrder();
returnOrder.setOrderNo(order.getOrderNo());
returnOrder = mybatisDao.selectOneByModel(returnOrder);
returnOrder.setReturnStatus(15);
mybatisDao.update(returnOrder);
//查询订单的退货商品信息
TbReturnOrderItemExample tbReturnOrderItemExample = new TbReturnOrderItemExample();
tbReturnOrderItemExample.createCriteria().andReturnOrderIdEqualTo(returnOrder.getId());
List<TbReturnOrderItem> tbReturnOrderItems = mybatisDao.selectByExample(tbReturnOrderItemExample);
for (TbReturnOrderItem tbReturnOrderItem : tbReturnOrderItems) {
//需要的退回库存
if (tbReturnOrderItem.getIsNeed() == 1) {
CdItem cdItem = new CdItem();
cdItem.setItemCode(tbReturnOrderItem.getItemCode());
cdItem = mybatisDao.selectOneByModel(cdItem);
stockService.changeStockNum(cdItem.getId(), tbReturnOrderItem.getItemNumber().intValue(), returnOrder.getId(), "订单退货退回商品", 3);
}
}
// 卡类订单进行退款
if (order.getOrderType() == 1) {
}
}
}
// 设置退货订单的状态为“退货中”（状态码1

22
src/main/java/com/xmomen/module/report/model/ExpressReport.java
Unescape View File

@ -17,22 +17,44 @@ public
@Data
class ExpressReport implements Serializable {
// 物流公司
// 物流公司
@Excel(name = "物流公司")
// 订单号
private String expressName;
// 订单号
// 总箱数
@Excel(name = "订单号", width = 20)
private String orderNo;
// 出库时间
// 总箱数
@Excel(name = "总箱数")
// 收货时间
private int totalBoxNum;
// 出库时间
// 二次配送
@Excel(name = "出库时间", width = 20, exportFormat = "yyyy-MM-dd HH:mm:ss")
// 收货时间
// 正常配送
private Date outDate;
@Excel(name = "收货时间", width = 20, exportFormat = "yyyy-MM-dd HH:mm:ss")
// 异常配送
// 二次配送
// 正常配送
// 物流代收款
private Date shouHuoDate;
@Excel(name = "二次配送", type = 10)
// 损失承担
// 异常配送
private int isTwoSend;
// 物流代收款
// 是否拒收
@Excel(name = "正常配送", type = 10)
// 损失承担
private int isNormal;
@Excel(name = "异常配送", type = 10)
private int isNoNormal;
// 是否拒收
@Excel(name = "物流代收款", width = 15, type = 10)
private double expressAmount;
@Excel(name = "损失承担", type = 10)

36
src/main/java/com/xmomen/module/report/model/FinanceReport.java
Unescape View File

@ -11,53 +11,57 @@ import java.io.Serializable;
public
@Data
class FinanceReport implements Serializable {
//公司ID
private int cdCompanyId;
//客户经理
@Excel(name = "客户经理")
private String managerName;
//单位/个人
@Excel(name = "单位/个人")
private String companyName;
//用户ID
private int cdUserId;
//总张数
//总张数（预付款）
@Excel(name = "总张数（预付款）", type = 10)
private int beforeCouponCount;
//总金额
//总金额（预付款）
@Excel(name = "总金额（预付款）", type = 10)
private double beforeTotalValue;
//充值金额
//充值金额（预付款）
@Excel(name = "充值金额（预付款）", type = 10)
private double beforeTotalRechargeValue;
//已付
//已付（预付款）
@Excel(name = "已付（预付款）", type = 10)
private double beforeTotalYesValue;
// 未付
// 未付（预付款）
@Excel(name = "未付（预付款）", type = 10)
private double beforeTotalNoValue;
// 余额
// 余额（预付款）
@Excel(name = "余额（预付款）", type = 10)
private double beforeUserTotalValue;
// 回馈总金额
// 回馈总金额（预付款）
@Excel(name = "回馈总金额（预付款）", type = 10)
private double beforeGiftTotalValue;
// 回馈剩余金额
// 回馈剩余金额（预付款）
@Excel(name = "回馈剩余金额（预付款）", type = 10)
private double beforeGiftUserTotalValue;
// 总张数
// 总张数（后付款）
@Excel(name = "总张数（后付款）", type = 10)
private int afterCouponCount;
// 总金额
// 总金额（后付款）
@Excel(name = "总金额（后付款）", type = 10)
private double afterTotalValue;
// 充值金额
// 充值金额（后付款）
@Excel(name = "充值金额（后付款）", type = 10)
private double afterTotalRechargeValue;
// 已付
// 已付（后付款）
@Excel(name = "已付（后付款）", type = 10)
private double afterTotalYesValue;
// 未付
// 未付（后付款）
@Excel(name = "未付（后付款）", type = 10)
private double afterTotalNoValue;
// 余额
// 余额（后付款）
@Excel(name = "余额（后付款）", type = 10)
private double afterUserTotalValue;
// 回馈总金额（后付款）
@ -78,12 +82,16 @@ class FinanceReport implements Serializable {
//回馈总金额
@Excel(name = "回馈总金额", type = 10)
private double giftOrderTotal;
//客户经理代收
@Excel(name = "客户经理代收", type = 10)
private double managerAmount;
//POS
@Excel(name = "POS", type = 10)
private double posAmount;
//转账
@Excel(name = "转账", type = 10)
private double zhuanAmount;
//物流代收
@Excel(name = "物流代收", type = 10)
private double expressAmount;
}

16
src/main/java/com/xmomen/module/report/model/OrderDeliveryReport.java
Unescape View File

@ -16,33 +16,49 @@ import java.util.Date;
public @Data
class OrderDeliveryReport implements Serializable {
// 下单日期
@Excel(name = "下单日期" , exportFormat="yyyy-MM-dd", importFormat = "yyyy-MM-dd")
private Date createTime;
// 订单号
@Excel(name = "订单号",width = 20)
private String orderNo;
// 快递商
@Excel(name="快递商")
private String expressName;
// 收货人姓名
@Excel(name = "收货人姓名",width = 15)
private String consigneeName;
// 收货人电话
@Excel(name = "收货人电话",width = 15)
private String consigneePhone;
// 收货人地址
@Excel(name = "收货人地址",width = 30)
private String consigneeAddress;
// 金额
@Excel(name = "金额")
private double totalAmount;
// 付款方式
@Excel(name = "付款方式")
private String paymentModeDesc;
// 付款金额
@Excel(name = "付款金额",type = 10)
private double payAmount;
// 附加付款方式
@Excel(name = "附加付款方式")
private String otherPaymentModeDesc;
// 附加付款金额
@Excel(name = "附加付款金额",type = 10)
private double otherPayAmount;
// 送货日期
@Excel(name = "送货日期" , exportFormat="yyyy-MM-dd", importFormat = "yyyy-MM-dd")
private Date appointmentTime;
// 备注
@Excel(name = "备注",width = 30)
private String remark;
// 订单状态描述
private String orderStatusDesc;
// 总箱数
private int totalBoxNum;
// 快递扫描箱数
private int expressScanBoxNum;
}

22
src/main/java/com/xmomen/module/report/model/OrderReport.java
Unescape View File

@ -17,45 +17,67 @@ public
@Data
class OrderReport implements Serializable {
// 支付方式
private String paymentMode;
// 支付金额
private double payAmount;
// 其他支付方式
private String otherPaymentMode;
// 其他支付金额
private double otherPayAmount;
// 订单类型
@Excel(name = "订单类型")
private String orderType;
// 订单号
@Excel(name = "订单号", width = 20)
private String orderNo;
// 客户姓名
@Excel(name = "客户姓名")
private String consigneeName;
// 电话
@Excel(name = "电话", width = 15)
private String consigneePhone;
// 单位/个人
@Excel(name = "单位/个人")
private String companyName;
// 客户经理
@Excel(name = "客户经理")
private String managerName;
// 物流公司
@Excel(name = "物流公司")
private String expressName;
// 总金额
@Excel(name = "总金额")
private double totalAmount;
// 折扣金额
@Excel(name = "折扣金额")
private double discountPrice;
// 客户经理代收
@Excel(name = "客户经理代收", width = 15, type = 10)
private double managerAmount;
// 物流代收
@Excel(name = "物流代收", type = 10)
private double expressAmount;
// 卡类扣款
@Excel(name = "卡类扣款", type = 10)
private double couponAmount;
// 券类扣款
@Excel(name = "券类扣款", type = 10)
private double quanAmount;
// 刷POS
@Excel(name = "刷POS", type = 10)
private double posAmount;
// 转账
@Excel(name = "转账", type = 10)
private double zhuanZhanAmount;
// 其它
@Excel(name = "其它", type = 10)
private double otherAmount;
// 回馈
@Excel(name = "回馈", type = 10)
private double huiKuiAmount;
// 退货金额
@Excel(name = "退货金额", type = 10)
private double returnTotalAmount;
}

5
src/main/java/com/xmomen/module/report/model/ReportQuery.java
Unescape View File

@ -5,11 +5,16 @@ import lombok.Data;
import java.io.Serializable;
/**
* 报表查询模型
*/
public @Data
class ReportQuery implements Serializable {
// 开始时间
private String beginTime;
// 结束时间
private String endTime;
// 管理员ID
private Integer managerId;
// 公司ID
private Integer companyId;
}

6
src/main/java/com/xmomen/module/report/model/StockDailyReport.java
Unescape View File

@ -5,14 +5,14 @@ import org.jeecgframework.poi.excel.annotation.Excel;
import java.io.Serializable;
/**
* 库存快照报表实体类
*/
public
@Data
class StockDailyReport implements Serializable {
// 商品名称
@Excel(name = "商品名称")
private String itemName;
// 商品编码
@Excel(name = "商品编码")
private String itemCode;
/**

4
src/main/java/com/xmomen/module/report/service/ReportOrderService.java
Unescape View File

@ -41,9 +41,13 @@ public class ReportOrderService {
* @return
*/
public List<OrderReport> getOrderReportList(ReportQuery reportQuery) {
//查询订单报表
List<OrderReport> orderReportList = mybatisDao.getSqlSessionTemplate().selectList(ReportOrderMapper.REPORT_ORDER_MAPPER_NAMESPACE + "getReportOrderList", reportQuery);
//遍历订单报表
for (OrderReport orderReport : orderReportList) {
//判断付款方式
if ("0".equals(orderReport.getPaymentMode())) {
//如果是汇款
orderReport.setHuiKuiAmount(orderReport.getPayAmount());
}
if ("1".equals(orderReport.getPaymentMode())) {

38
src/main/java/com/xmomen/module/resource/api/DfsException.java
Unescape View File

@ -1,38 +1,66 @@
package com.xmomen.module.resource.api;
/**
* DfsException 类继承自 RuntimeException，用于表示在分布式文件系统（DFS）操作过程中出现的异常。
*/
public class DfsException extends RuntimeException {
// 序列化版本号，用于确保在反序列化时类的版本一致性
private static final long serialVersionUID = 1497374765949093902L;
/**
* IOException 100
* FileNotFoundException 200
* Exception from DFS (example: from FastDFS, MyException) 300
* OtherException 400
* 异常代码，用于标识不同类型的异常。
* 异常代码的具体含义如下：
* - IOException 对应代码 100
* - FileNotFoundException 对应代码 200
* - 来自 DFS 的异常（例如 FastDFS 抛出的异常、自定义异常 MyException）对应代码 300
* - 其他异常对应代码 400
*/
private String code;
// 异常的详细描述信息
private String message;
/**
* 构造函数，用于创建一个 DfsException 实例。
* @param code 异常代码，用于标识异常类型
* @param message 异常的详细描述信息
*/
public DfsException(String code, String message) {
this.code = code;
this.message = message;
}
/**
* 获取异常代码。
* @return 异常代码
*/
public String getCode() {
return code;
}
/**
* 设置异常代码。
* @param code 要设置的异常代码
*/
public void setCode(String code) {
this.code = code;
}
/**
* 获取异常的详细描述信息。
* @return 异常的详细描述信息
*/
public String getMessage() {
return message;
}
/**
* 设置异常的详细描述信息。
* @param message 要设置的异常详细描述信息
*/
public void setMessage(String message) {
this.message = message;
}
}
}

59
src/main/java/com/xmomen/module/resource/api/DfsFile.java
Unescape View File

@ -2,32 +2,45 @@ package com.xmomen.module.resource.api;
import java.util.Map;
/**
* DfsFile 类代表一个分布式文件系统（DFS）中的文件。
* 该类封装了文件的数据、唯一标识以及元数据信息。
*/
public class DfsFile {
/**
* file data
* 存储文件的二进制数据。
* 它包含了文件的实际内容，以字节数组的形式存在。
*/
private byte[] data;
/**
* key,not used in FastDfs
* 文件的唯一标识。
* 在 FastDFS 这种分布式文件系统中，此属性暂不使用。
*/
private String key;
/**
* metadata for file
* 文件的元数据信息。
* 以键值对的形式存储与文件相关的额外信息，
* 例如文件的创建时间、作者、文件类型等。
*/
private Map<String, String> metadata;
/**
* 默认构造函数。
* 用于创建一个空的 DfsFile 对象，各属性初始值为 null。
*/
public DfsFile() {
}
/**
* constructor with data, key and metadata
* 带参数的构造函数，用于创建一个具有指定属性的 DfsFile 对象。
*
* @param key key,not used in FastDfs
* @param data file data
* @param metadata metadata for file
* @param key 文件的唯一标识，在 FastDFS 中暂不使用。
* @param data 文件的二进制数据。
* @param metadata 文件的元数据信息，以键值对形式存储。
*/
public DfsFile(String key, byte[] data, Map<String, String> metadata) {
this.key = key;
@ -35,28 +48,58 @@ public class DfsFile {
this.metadata = metadata;
}
/**
* 获取文件的二进制数据。
*
* @return 文件的二进制数据，以字节数组形式返回。
*/
public byte[] getData() {
return data;
}
/**
* 设置文件的二进制数据。
*
* @param data 要设置的文件二进制数据。
*/
public void setData(byte[] data) {
this.data = data;
}
/**
* 获取文件的唯一标识。
*
* @return 文件的唯一标识。
*/
public String getKey() {
return key;
}
/**
* 设置文件的唯一标识。
*
* @param key 要设置的文件唯一标识。
*/
public void setKey(String key) {
this.key = key;
}
/**
* 获取文件的元数据信息。
*
* @return 文件的元数据信息，以键值对形式返回。
*/
public Map<String, String> getMetadata() {
return metadata;
}
/**
* 设置文件的元数据信息。
*
* @param metadata 要设置的文件元数据信息，以键值对形式传入。
*/
public void setMetadata(Map<String, String> metadata) {
this.metadata = metadata;
}
}
}

41
src/main/java/com/xmomen/module/resource/api/DfsPath.java
Unescape View File

@ -1,45 +1,74 @@
package com.xmomen.module.resource.api;
/**
* DfsPath 类用于表示分布式文件系统（DFS）中文件的路径信息。
* 它包含了文件的 HTTP 访问路径和存储服务器上的远程路径。
*/
public class DfsPath {
/**
* whole url, just like http://.../bucketName/remotePath
* 完整的 HTTP 访问路径，格式类似于 http://.../bucketName/remotePath。
* 该路径可用于在网络上直接访问文件。
*/
private String httpPath;
/**
* file path on storage server
* 文件在存储服务器上的路径。
* 它表示文件在存储服务器的实际存储位置。
*/
private String remotePath;
/**
* 默认构造函数，用于创建一个 DfsPath 对象，其属性初始值为 null。
*/
public DfsPath() {
}
/**
* Constructor with httpPath and remotePath
* 带参数的构造函数，用于创建一个具有指定 HTTP 路径和远程路径的 DfsPath 对象。
*
* @param httpPath
* @param remotePath
* @param httpPath 文件的完整 HTTP 访问路径
* @param remotePath 文件在存储服务器上的路径
*/
public DfsPath(String httpPath, String remotePath) {
this.httpPath = httpPath;
this.remotePath = remotePath;
}
/**
* 获取文件的完整 HTTP 访问路径。
*
* @return 文件的 HTTP 访问路径
*/
public String getHttpPath() {
return httpPath;
}
/**
* 设置文件的完整 HTTP 访问路径。
*
* @param httpPath 要设置的 HTTP 访问路径
*/
public void setHttpPath(String httpPath) {
this.httpPath = httpPath;
}
/**
* 获取文件在存储服务器上的路径。
*
* @return 文件在存储服务器上的路径
*/
public String getRemotePath() {
return remotePath;
}
/**
* 设置文件在存储服务器上的路径。
*
* @param remotePath 要设置的存储服务器上的路径
*/
public void setRemotePath(String remotePath) {
this.remotePath = remotePath;
}
}
}

3
src/main/java/com/xmomen/module/resource/api/DfsSdk.java
Unescape View File

@ -4,7 +4,9 @@ import java.io.File;
public class DfsSdk {
// 根据dfsType和bucketName获取DfsService实例
public static DfsService getDfsInstance(String dfsType, String bucketName) {
// 如果dfsType为FastDFS，则获取FastDfsService实例
if ("FastDFS".equalsIgnoreCase(dfsType)) {
DfsService dfsService = FastDfsService.getInstance(bucketName);
return dfsService;
@ -12,6 +14,7 @@ public class DfsSdk {
return null;
}
// 默认获取FastDFS的DfsService实例
public static DfsService getDfsInstance() {
return getDfsInstance("FastDFS", "group1");
}

82
src/main/java/com/xmomen/module/resource/api/DfsService.java
Unescape View File

@ -4,73 +4,91 @@ import java.io.File;
import java.util.List;
import java.util.Map;
/**
* DfsService 接口定义了与分布式文件系统（DFS）进行交互的一系列操作。
* 这些操作涵盖了文件的上传、下载、删除、列表获取以及路径获取等功能。
*/
public interface DfsService {
/**
* Upload file to file system.
* 将本地文件上传到分布式文件系统。
*
* @param filePath local file path
* @param key Key
* @param metadata metadata for the file
* @return DfsPath object or null if fail
* @param filePath 文件在本地的路径，用于定位要上传的文件。
* @param key 文件的唯一标识，可用于区分不同的文件。
* @param metadata 文件的元数据，以键值对的形式存储额外信息。
* @return 若上传成功，返回包含文件在 DFS 中路径信息的 DfsPath 对象；若失败则返回 null。
*/
public DfsPath putObject(String filePath, String key, Map<String, String> metadata);
/**
* Upload file to file system
* 将 File 对象表示的文件上传到分布式文件系统。
*
* @param file file
* @param key Key
* @param metadata metadata for the file
* @return DfsPath object or null if fail
* @param file 要上传的文件对象。
* @param key 文件的唯一标识，用于区分不同的文件。
* @param metadata 文件的元数据，以键值对的形式存储额外信息。
* @return 若上传成功，返回包含文件在 DFS 中路径信息的 DfsPath 对象；若失败则返回 null。
*/
public DfsPath putObject(File file, String key, Map<String, String> metadata);
/**
* Upload file to file system
* 将字节数组形式的文件内容上传到分布式文件系统。
*
* @param bytes file
* @param key Key
* @param metadata metadata for the file
* @param extName ext name of file
* @return DfsPath object or null if fail
* @param bytes 文件的字节数据，代表文件的实际内容。
* @param key 文件的唯一标识，用于区分不同的文件。
* @param metadata 文件的元数据，以键值对的形式存储额外信息。
* @param extName 文件的扩展名，用于标识文件类型。
* @return 若上传成功，返回包含文件在 DFS 中路径信息的 DfsPath 对象；若失败则返回 null。
*/
public DfsPath putObject(byte[] bytes, String key, Map<String, String> metadata, String extName);
/**
* Get file from file system with remotePath
* 从分布式文件系统中根据远程路径和键获取文件。
*
* @param remotePath remote file path on file system
* @param key Key
* @return DfsPath object or null if fail
* @param remotePath 文件在分布式文件系统中的远程路径，用于定位文件。
* @param key 文件的唯一标识，用于验证文件的身份。
* @return 若获取成功，返回包含文件数据和元信息的 DfsFile 对象；若失败则返回 null。
*/
public DfsFile getObject(String remotePath, String key);
/**
* Delete the file on file system
* 从分布式文件系统中删除指定远程路径和键对应的文件。
*
* @param remotePath remote file path on file system
* @param key Key
* @return true||false
* @param remotePath 文件在分布式文件系统中的远程路径，用于定位要删除的文件。
* @param key 文件的唯一标识，用于验证要删除的文件。
* @return 若删除成功，返回 true；若失败则返回 false。
*/
public boolean deleteObject(String remotePath, String key);
/**
* Get the list of the file on file system
* 获取分布式文件系统中的文件列表。
*
* @return List<DfsFile>
* @return 返回一个包含 DfsFile 对象的列表，每个对象代表文件系统中的一个文件；若列表为空则返回空列表。
*/
public List<DfsFile> listObjects();
/**
* Get the whole url
* 根据文件在分布式文件系统中的远程路径获取其完整的 HTTP 访问路径。
*
* @param remotePath
* @return whole url
* @param remotePath 文件在分布式文件系统中的远程路径。
* @return 返回文件的完整 HTTP 访问路径，可用于在网络上访问该文件。
*/
public String getHttpPath(String remotePath);
/**
* 根据 DMS 文件路径获取其对应的完整 HTTP 访问路径。
* DMS 可能是某种特定的文件管理系统。
*
* @param dmsFilePath DMS 系统中的文件路径。
* @return 返回该文件对应的完整 HTTP 访问路径。
*/
public String getDmsHttpPath(String dmsFilePath);
/**
* 根据指定的类型获取默认路径。
* 这里的类型可能是文件的分类、用途等，具体含义取决于实现。
*
* @param type 文件的类型标识。
* @return 返回对应类型的默认路径。
*/
public String getDefaultPath(String type);
}
}

259
src/main/java/com/xmomen/module/resource/api/FastDfsService.java
Unescape View File

@ -19,58 +19,77 @@ import org.csource.fastdfs.StorageServer;
import org.csource.fastdfs.TrackerClient;
import org.csource.fastdfs.TrackerServer;
/**
* FastDfsService 类实现了 DfsService 接口，用于与 FastDFS 分布式文件系统进行交互。
* 该类采用单例模式，确保在整个应用中只有一个实例与 FastDFS 进行通信。
*/
public class FastDfsService implements DfsService {
// 单例实例
private static FastDfsService instance = null;
// 基础 URL，用于构建文件的完整 HTTP 访问路径
private String baseUrl = "";
// DMS 基础 URL，用于构建 DMS 文件的完整 HTTP 访问路径
private String dmsBaseUrl = "";
// 默认图片 URL
private String defaultPicUrl = "";
//private static Logger logger = Logger.getLogger(FastDfsService.class.getName());
// 配置文件中基础 URL 的键名
private static String BASE_URL = "httpBaseUrl";
// 配置文件中 DMS 基础 URL 的键名
private static String DMS_BASE_URL = "dmsBaseUrl";
// 配置文件中默认图片 URL 的键名
private static String DEFAULT_PIC_URL = "defaultPicUrl";
// FastDFS 键名，用于元数据中存储文件的唯一标识
private static String FAST_DFS_KEY = "FastDfsKey";
/**
* bucket name
* 存储文件的桶名
*/
private final String bucketName;
/**
* constructor with bucketName
* 私有构造函数，用于初始化 FastDfsService 实例。
* 该构造函数会读取 FastDFS 配置文件，并初始化客户端全局配置。
*
* @param bucketName bucket name
* @param bucketName 存储文件的桶名
*/
private FastDfsService(String bucketName) {
this.bucketName = bucketName;
String configFilePath = null;
try {
configFilePath = FastDfsService.class.getResource("/").toURI().getPath() + "fdfs_client.conf";
} catch (URISyntaxException e1) {
Exception e = new Exception("Cann't found fdfs_client.conf file under " + FastDfsService.class.getResource("/"));
handleException(e);
}
try {
// 获取 FastDFS 配置文件的路径
configFilePath = FastDfsService.class.getResource("/").toURI().getPath() + "fdfs_client.conf";
} catch (URISyntaxException e1) {
// 若无法找到配置文件，抛出异常并处理
Exception e = new Exception("Cann't found fdfs_client.conf file under " + FastDfsService.class.getResource("/"));
handleException(e);
}
try {
// 初始化 FastDFS 客户端全局配置
ClientGlobal.init(configFilePath);
// 读取配置文件
IniFileReader reader = new IniFileReader(configFilePath);
// 设置基础 URL
setBaseUrl(reader.getStrValue(BASE_URL));
// 设置 DMS 基础 URL
setDmsBaseUrl(reader.getStrValue(DMS_BASE_URL));
// 设置默认图片 URL
setDefaultPicUrl(reader.getStrValue(DEFAULT_PIC_URL));
} catch (Exception e) {
// 处理初始化过程中出现的异常
handleException(e);
}
}
/**
* Get instance of FastDfsService, for Singleton
* @param bucketName bucket name
* @return instance of FastDfsService
* 获取 FastDfsService 单例实例的方法。
* 采用双重检查锁定机制确保线程安全。
*
* @param bucketName 存储文件的桶名
* @return FastDfsService 单例实例
*/
public static synchronized FastDfsService getInstance(String bucketName) {
if (null == instance) {
@ -80,11 +99,11 @@ public class FastDfsService implements DfsService {
}
/**
* Delete file on file system.
* 从文件系统中删除指定的文件。
*
* @param remotePath remote file path
* @param key Key, not used in FastDFS
* @return true|false
* @param remotePath 远程文件路径
* @param key 文件的键，在 FastDFS 中未使用
* @return 删除成功返回 true，失败返回 false
*/
@Override
public boolean deleteObject(String remotePath, String key) {
@ -92,21 +111,28 @@ public class FastDfsService implements DfsService {
TrackerClient trackerClient = new TrackerClient();
TrackerServer trackerServer = null;
try {
// 获取 Tracker 服务器连接
trackerServer = trackerClient.getConnection();
// 创建存储客户端
StorageClient storageClient = new StorageClient(trackerServer, null);
// 调用 FastDFS API 删除文件
result = storageClient.delete_file(bucketName, remotePath);
} catch(Exception e) {
} catch (Exception e) {
// 处理删除过程中出现的异常
handleException(e);
} finally {
if (null != trackerServer) {
try {
// 关闭 Tracker 服务器连接
trackerServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
}
if (0 != result) {
// 删除失败，记录日志并返回 false
//logger.info("delete faild, the faild code is: " + result);
return false;
}
@ -114,26 +140,33 @@ public class FastDfsService implements DfsService {
}
/**
* Find the whole url
* 根据远程路径构建文件的完整 HTTP 访问路径。
*
* @param remotePath remote path
* @return the whole url
* @param remotePath 远程文件路径
* @return 文件的完整 HTTP 访问路径
*/
@Override
public String getHttpPath(String remotePath) {
return baseUrl + "/" + bucketName + "/" + remotePath;
}
/**
* 根据 DMS 文件路径构建其完整的 HTTP 访问路径。
*
* @param dmsFilePath DMS 文件路径
* @return DMS 文件的完整 HTTP 访问路径
*/
@Override
public String getDmsHttpPath(String dmsFilePath) {
return dmsBaseUrl + dmsFilePath;
return dmsBaseUrl + dmsFilePath;
}
/**
* Get the file, and return DfsFile object
* 从文件系统中获取指定的文件。
*
* @param remotePath remote path
* @param key Key, not used in FastDFS, can be null
* @return DfsFile object or null if fail
* @param remotePath 远程文件路径
* @param key 文件的键，在 FastDFS 中未使用，可以为 null
* @return 若获取成功，返回 DfsFile 对象；否则返回 null
*/
@Override
public DfsFile getObject(String remotePath, String key) {
@ -141,59 +174,75 @@ public class FastDfsService implements DfsService {
TrackerServer trackerServer = null;
StorageServer storageServer = null;
try {
// 获取 Tracker 服务器连接
trackerServer = trackerClient.getConnection();
// 获取存储服务器
storageServer = trackerClient.getFetchStorage(trackerServer, bucketName, remotePath);
// 创建存储客户端
StorageClient storageClient = new StorageClient(trackerServer, storageServer);
// 下载文件
byte[] bytes = storageClient.download_file(this.bucketName, remotePath);
if (null != bytes) {
// 获取文件的元数据
NameValuePair[] value_pairs = storageClient.get_metadata(bucketName, remotePath);
Map<String, String> metadata = new HashMap<String, String>();
for (int i = 0; i < value_pairs.length; i++) {
// 将元数据存储到 Map 中
metadata.put(value_pairs[i].getName(), value_pairs[i].getValue());
}
// 创建 DfsFile 对象
DfsFile dfsFile = new DfsFile(metadata.get(FAST_DFS_KEY), bytes, metadata);
return dfsFile;
}
} catch (Exception e){
} catch (Exception e) {
// 处理获取文件过程中出现的异常
handleException(e);
} finally {
if (null != storageServer) {
try {
// 关闭存储服务器连接
storageServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
if (null != trackerServer) {
try {
// 关闭 Tracker 服务器连接
trackerServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
}
// 获取文件失败，记录日志并返回 null
//logger.info("Get object failed, get null object");
return null;
}
/**
* Get the file list of file system.
* Not implement at the moment, because FastDFS API not support.
* 获取文件系统中的文件列表。
* 目前由于 FastDFS API 不支持，该方法未实现。
*
* @return 始终返回 null
*/
@Override
public List<DfsFile> listObjects() {
//to do
//Because fastDFS api do not support list object method.
// 待实现
// 因为 FastDFS API 不支持列出对象的方法
return null;
}
/**
* Upload the file to file system by file path
* 通过文件路径将文件上传到文件系统。
* 该方法会将文件转换为 File 对象，然后调用 putObject(File file, String key, Map<String, String> metadata) 方法进行上传。
*
* @param filePath local file path.
* @param key Key, not used in FastDFS, can be null
* @param metadata metadata for file, can be null
* @return DfsFile object or null if fail
* @param filePath 本地文件路径
* @param key 文件的键，在 FastDFS 中未使用，可以为 null
* @param metadata 文件的元数据，可以为 null
* @return 若上传成功，返回 DfsPath 对象；否则返回 null
*/
@Override
public DfsPath putObject(String filePath, String key, Map<String, String> metadata) {
@ -202,13 +251,13 @@ public class FastDfsService implements DfsService {
}
/**
* Upload the file to file system by bytes
* 通过字节数组将文件上传到文件系统。
*
* @param bytes bytes
* @param key Key, not used in FastDFS
* @param metadata metadata for file, can be null
* @param extName extName for file, can be null
* @return DfsPath object or null if fail
* @param bytes 文件的字节数组
* @param key 文件的键，在 FastDFS 中未使用
* @param metadata 文件的元数据，可以为 null
* @param extName 文件的扩展名，可以为 null
* @return 若上传成功，返回 DfsPath 对象；否则返回 null
*/
@Override
public DfsPath putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) {
@ -216,147 +265,215 @@ public class FastDfsService implements DfsService {
TrackerServer trackerServer = null;
StorageServer storageServer = null;
try {
// 获取 Tracker 服务器连接
trackerServer = trackerClient.getConnection();
// 获取存储服务器列表
StorageServer[] storageServers = trackerClient.getStoreStorages(trackerServer, bucketName);
if (null != storageServers) {
// 选择第一个存储服务器
storageServer = storageServers[0];
// 创建存储客户端
StorageClient storageClient = new StorageClient(trackerServer, storageServer);
NameValuePair[] meta_list;
int i = 0;
if (null == metadata) {
// 若元数据为空，创建一个包含一个元素的元数据数组
meta_list = new NameValuePair[1];
} else {
// 若元数据不为空，创建一个包含元数据和 FastDFS 键的数组
meta_list = new NameValuePair[metadata.size() + 1];
for (Map.Entry<String, String> entry : metadata.entrySet()) {
meta_list[i++] = new NameValuePair(entry.getKey(), entry.getValue());
}
}
// 添加 FastDFS 键到元数据数组
meta_list[i] = new NameValuePair(FAST_DFS_KEY, key);
// 调用 FastDFS API 上传文件
String[] results = storageClient.upload_file(bytes, extName, meta_list);
if (null == results) {
// 上传失败，记录日志并返回 null
//logger.info("upload file fail, error codes: " + storageClient.getErrorCode());
return null;
} else {
// 获取远程文件名
String remote_fileName = results[1];
// 构建文件的完整 HTTP 访问路径
String httpPath = this.getHttpPath(remote_fileName);
// 创建 DfsPath 对象
DfsPath dfsPath = new DfsPath(httpPath, remote_fileName);
return dfsPath;
}
}
} catch (Exception e) {
// 处理上传过程中出现的异常
handleException(e);
} finally {
if (null != storageServer) {
try {
// 关闭存储服务器连接
storageServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
if (null != trackerServer) {
try {
// 关闭 Tracker 服务器连接
trackerServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
}
// 上传失败，记录日志并返回 null
//logger.info("Upload file faild, because can not get storage servers!");
return null;
}
/**
* Upload the file to file system
* 将文件上传到文件系统。
* 该方法会将文件转换为字节数组，然后调用 putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) 方法进行上传。
*
* @param file file
* @param key Key, not used in FastDFS, can be null
* @param metadata metadata for file , can be null
* @return DfsPath object or null if fail
* @param file 文件对象
* @param key 文件的键，在 FastDFS 中未使用，可以为 null
* @param metadata 文件的元数据，可以为 null
* @return 若上传成功，返回 DfsPath 对象；否则返回 null
*/
@Override
public DfsPath putObject(File file, String key, Map<String, String> metadata) {
FileInputStream in = null;
byte[] file_buff = null;
try {
// 打开文件输入流
in = new FileInputStream(file);
if (null != in) {
// 获取文件长度
int len = in.available();
// 创建字节数组
file_buff = new byte[len];
// 读取文件内容到字节数组
in.read(file_buff);
}
} catch (Exception e) {
// 处理读取文件过程中出现的异常
handleException(e);
} finally {
if (null != in) {
try {
// 关闭文件输入流
in.close();
} catch (Exception e) {
// 处理关闭流时出现的异常
handleException(e);
}
}
}
String file_ext_name = "";
if (file.getName().lastIndexOf(".") > 0) {
// 获取文件扩展名
file_ext_name = file.getName().substring(file.getName().lastIndexOf(".") + 1);
}
// 调用 putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) 方法上传文件
return putObject(file_buff, key, metadata, file_ext_name);
}
/**
* 获取基础 URL。
*
* @return 基础 URL
*/
public String getBaseUrl() {
return baseUrl;
}
/**
* 设置基础 URL。
*
* @param baseUrl 要设置的基础 URL
*/
private void setBaseUrl(String baseUrl) {
this.baseUrl = baseUrl;
}
/**
* 获取 DMS 基础 URL。
*
* @return DMS 基础 URL
*/
public String getDmsBaseUrl() {
return dmsBaseUrl;
return dmsBaseUrl;
}
/**
* 设置 DMS 基础 URL。
*
* @param dmsBaseUrl 要设置的 DMS 基础 URL
*/
public void setDmsBaseUrl(String dmsBaseUrl) {
this.dmsBaseUrl = dmsBaseUrl;
this.dmsBaseUrl = dmsBaseUrl;
}
/**
* 获取默认图片 URL。
*
* @return 默认图片 URL
*/
public String getDefaultPicUrl() {
return defaultPicUrl;
return defaultPicUrl;
}
/**
* 设置默认图片 URL。
*
* @param defaultPicUrl 要设置的默认图片 URL
*/
public void setDefaultPicUrl(String defaultPicUrl) {
this.defaultPicUrl = defaultPicUrl;
this.defaultPicUrl = defaultPicUrl;
}
/**
* Handle Exception
* @param e exception
* 处理异常的方法。
* 根据异常类型抛出不同的 DfsException 异常。
*
* @param e 要处理的异常
*/
private void handleException(Exception e) {
if (e instanceof IOException) {
// 处理 IOException，抛出 DfsException，错误码为 100
//logger.error("Exception occured : DFSException code: 100," + " exception message :" + e.getMessage());
throw new DfsException("100", e.getMessage());
} else if (e instanceof FileNotFoundException) {
// 处理 FileNotFoundException，抛出 DfsException，错误码为 200
//logger.error("Exception occured : DFSException code: 200," + " exception message : file not found." + e.getMessage());
throw new DfsException("200", e.getMessage());
} else if (e instanceof MyException) {
// 处理 MyException，抛出 DfsException，错误码为 300
//logger.error("Exception occured : DFSException code: 300," + " exception message :" + e.getMessage());
throw new DfsException("300", e.getMessage());
} else if (e instanceof Exception) {
// 处理其他异常，抛出 DfsException，错误码为 400
//logger.error("Exception occured : DFSException code: 400," + " exception message :" + e.getMessage());
throw new DfsException("400", e.getMessage());
}
}
@Override
public String getDefaultPath(String type) {
if("PICTURE".equalsIgnoreCase(type)) {
return defaultPicUrl;
}
return defaultPicUrl;
}
}
/**
* 根据类型获取默认路径。
* 如果类型为 "PICTURE"，则返回默认图片 URL；否则也返回默认图片 URL。
*
* @param type 路径类型
* @return 默认路径
*/
@Override
public String getDefaultPath(String type) {
if ("PICTURE".equalsIgnoreCase(type)) {
return defaultPicUrl;
}
return defaultPicUrl;
}
}

145
src/main/java/com/xmomen/module/resource/controller/ResourceController.java
Unescape View File

@ -1,130 +1,203 @@
// 声明该类所在的包，此包为资源控制器相关的包
package com.xmomen.module.resource.controller;
// 导入自定义框架中的业务异常类，用于处理业务逻辑中出现的异常
import com.xmomen.framework.exception.BusinessException;
// 导入自定义框架中 MyBatis 分页相关的 Page 类，用于处理分页查询结果
import com.xmomen.framework.mybatis.page.Page;
// 导入自定义模块中的日志注解，用于记录操作日志
import com.xmomen.module.logger.Log;
// 导入资源查询模型类，用于封装资源查询的条件
import com.xmomen.module.resource.model.ResourceQuery;
// 导入资源数据模型类，用于封装资源的相关数据
import com.xmomen.module.resource.model.ResourceModel;
// 导入资源服务类，该类包含资源相关的业务逻辑
import com.xmomen.module.resource.service.ResourceService;
// 导入 Apache Commons IO 工具类，用于处理输入输出流
import org.apache.commons.io.IOUtils;
// 导入 Jeecg 框架中 Excel 导入工具类，用于从 Excel 文件中导入数据
import org.jeecgframework.poi.excel.ExcelImportUtil;
// 导入 Jeecg 框架中 Excel 导出参数类，用于配置 Excel 导出的参数
import org.jeecgframework.poi.excel.entity.ExportParams;
// 导入 Jeecg 框架中 Excel 导入参数类，用于配置 Excel 导入的参数
import org.jeecgframework.poi.excel.entity.ImportParams;
// 导入 Jeecg 框架中 Excel 导入结果类，用于封装 Excel 导入的结果
import org.jeecgframework.poi.excel.entity.result.ExcelImportResult;
// 导入 Jeecg 框架中普通 Excel 常量类，包含一些 Excel 操作的常量
import org.jeecgframework.poi.excel.entity.vo.NormalExcelConstants;
// 导入 Jeecg 框架中 Excel 导入异常类，用于处理 Excel 导入过程中出现的异常
import org.jeecgframework.poi.exception.excel.ExcelImportException;
// 导入 Spring 框架中的自动装配注解，用于自动注入依赖的 Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 框架中的模型映射类，用于在控制器和视图之间传递数据
import org.springframework.ui.ModelMap;
// 导入 Spring 框架中的数据绑定结果类，用于处理数据绑定过程中的错误信息
import org.springframework.validation.BindingResult;
// 导入 Spring 框架中的请求映射相关注解，用于处理 HTTP 请求
import org.springframework.web.bind.annotation.*;
// 导入 Spring 框架中用于处理多部分文件上传的类
import org.springframework.web.multipart.MultipartFile;
// 导入 Spring 框架中的模型和视图类，用于返回包含模型数据和视图名称的对象
import org.springframework.web.servlet.ModelAndView;
// 导入 JSR-303 验证框架中的有效注解，用于对请求参数进行验证
import javax.validation.Valid;
// 导入 Java 序列化接口，用于支持对象的序列化和反序列化
import java.io.Serializable;
// 导入 Java 输入输出异常类，用于处理输入输出操作中出现的异常
import java.io.IOException;
// 导入 Java 输入流类，用于读取数据
import java.io.InputStream;
// 导入 Java 列表接口，用于存储多个元素
import java.util.List;
/**
* 资源控制器类，负责处理与资源目录相关的 HTTP 请求。
*
* @author tanxinzheng
* @version 1.0.0
* @date 2017-4-10 23:26:20
*/
// 标记该类为 RESTful 风格的控制器，会自动将方法返回值转换为 JSON 格式
@RestController
// 定义该控制器处理的请求路径前缀为 /resource
@RequestMapping(value = "/resource")
public class ResourceController {
// 使用自动装配注解将 ResourceService 注入到当前类中，用于调用资源相关的业务逻辑
@Autowired
ResourceService resourceService;
/**
* 资源目录列表
* 处理获取资源目录列表的请求。
*
* @param limit 每页结果数
* @param offset 页码
* @param id 主键
* @param ids 主键数组
* @param excludeIds 不包含主键数组
* @return Page<ResourceModel> 资源目录领域分页对象
* @param limit 每页显示的结果数量
* @param offset 当前页码
* @param id 资源的主键，可选参数
* @param entityType 资源所属的实体类型，可选参数
* @param entityId 资源所属的实体 ID，可选参数
* @param ids 资源主键数组，可选参数
* @param excludeIds 不包含的资源主键数组，可选参数
* @return 包含资源目录数据的分页对象
*/
// 映射 HTTP GET 请求到该方法
@RequestMapping(method = RequestMethod.GET)
// 使用日志注解记录该操作的名称为查询资源目录列表
@Log(actionName = "查询资源目录列表")
public Page<ResourceModel> getResourceList(@RequestParam(value = "limit") Integer limit,
@RequestParam(value = "offset") Integer offset,
@RequestParam(value = "id", required = false) String id,
@RequestParam(value = "entityType", required = false) String entityType,
@RequestParam(value = "entityId", required = false) String entityId,
@RequestParam(value = "ids", required = false) String[] ids,
@RequestParam(value = "excludeIds", required = false) String[] excludeIds) {
public Page<ResourceModel> getResourceList(
// 从请求参数中获取每页结果数
@RequestParam(value = "limit") Integer limit,
// 从请求参数中获取页码
@RequestParam(value = "offset") Integer offset,
// 从请求参数中获取资源主键，该参数可选
@RequestParam(value = "id", required = false) String id,
// 从请求参数中获取资源所属的实体类型，该参数可选
@RequestParam(value = "entityType", required = false) String entityType,
// 从请求参数中获取资源所属的实体 ID，该参数可选
@RequestParam(value = "entityId", required = false) String entityId,
// 从请求参数中获取资源主键数组，该参数可选
@RequestParam(value = "ids", required = false) String[] ids,
// 从请求参数中获取不包含的资源主键数组，该参数可选
@RequestParam(value = "excludeIds", required = false) String[] excludeIds) {
// 创建资源查询对象
ResourceQuery resourceQuery = new ResourceQuery();
// 设置查询条件：资源主键
resourceQuery.setId(id);
// 设置查询条件：不包含的资源主键数组
resourceQuery.setExcludeIds(excludeIds);
// 设置查询条件：资源主键数组
resourceQuery.setIds(ids);
// 设置查询条件：资源所属的实体类型
resourceQuery.setEntityType(entityType);
// 设置查询条件：资源所属的实体 ID
resourceQuery.setEntityId(entityId);
// 调用资源服务的方法，根据分页信息和查询条件获取资源目录分页数据
return resourceService.getResourceModelPage(limit, offset, resourceQuery);
}
/**
* 查询单个资源目录
* 处理获取单个资源目录的请求。
*
* @param id 主键
* @return ResourceModel 资源目录领域对象
* @param id 资源的主键
* @return 资源目录的数据模型对象
*/
// 映射形如 /resource/{id} 的 HTTP GET 请求到该方法
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
// 使用日志注解记录该操作的名称为查询资源目录
@Log(actionName = "查询资源目录")
public ResourceModel getResourceById(@PathVariable(value = "id") String id) {
public ResourceModel getResourceById(
// 从路径中获取资源主键
@PathVariable(value = "id") String id) {
// 调用资源服务的方法，根据主键获取单个资源目录的数据
return resourceService.getOneResourceModel(id);
}
/**
* 新增资源目录
* 处理新增资源目录的请求。
*
* @param resourceModel 新增对象参数
* @return ResourceModel 资源目录领域对象
* @param resourceModel 包含新增资源目录信息的数据模型对象
* @return 新增后的资源目录的数据模型对象
*/
// 映射 HTTP POST 请求到该方法
@RequestMapping(method = RequestMethod.POST)
// 使用日志注解记录该操作的名称为新增资源目录
@Log(actionName = "新增资源目录")
public ResourceModel createResource(@RequestBody @Valid ResourceModel resourceModel) {
public ResourceModel createResource(
// 从请求体中获取新增资源目录的数据，并进行数据验证
@RequestBody @Valid ResourceModel resourceModel) {
// 调用资源服务的方法，创建新的资源目录
return resourceService.createResource(resourceModel);
}
/**
* 更新资源目录
* 处理更新资源目录的请求。
*
* @param id 主键
* @param resourceModel 更新对象参数
* @param id 要更新的资源的主键
* @param resourceModel 包含更新后资源目录信息的数据模型对象
*/
// 映射形如 /resource/{id} 的 HTTP PUT 请求到该方法
@RequestMapping(value = "/{id}", method = RequestMethod.PUT)
// 使用日志注解记录该操作的名称为更新资源目录
@Log(actionName = "更新资源目录")
public void updateResource(@PathVariable(value = "id") String id,
@RequestBody @Valid ResourceModel resourceModel) {
public void updateResource(
// 从路径中获取要更新的资源主键
@PathVariable(value = "id") String id,
// 从请求体中获取更新后的资源目录数据，并进行数据验证
@RequestBody @Valid ResourceModel resourceModel) {
// 调用资源服务的方法，更新资源目录信息
resourceService.updateResource(resourceModel);
}
/**
* 删除资源目录
* 处理删除单个资源目录的请求。
*
* @param id 主键
* @param id 要删除的资源的主键
*/
// 映射形如 /resource/{id} 的 HTTP DELETE 请求到该方法
@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
// 使用日志注解记录该操作的名称为删除单个资源目录
@Log(actionName = "删除单个资源目录")
public void deleteResource(@PathVariable(value = "id") String id) {
public void deleteResource(
// 从路径中获取要删除的资源主键
@PathVariable(value = "id") String id) {
// 调用资源服务的方法，删除指定主键的资源目录
resourceService.deleteResource(id);
}
/**
* 删除资源目录
* 处理批量删除资源目录的请求。
*
* @param ids 主键
* @param ids 要删除的资源的主键数组
*/
// 映射 HTTP DELETE 请求到该方法
@RequestMapping(method = RequestMethod.DELETE)
// 使用日志注解记录该操作的名称为批量删除资源目录
@Log(actionName = "批量删除资源目录")
public void deleteResources(@RequestParam(value = "ids") String[] ids) {
public void deleteResources(
// 从请求参数中获取要删除的资源主键数组
@RequestParam(value = "ids") String[] ids) {
// 调用资源服务的方法，批量删除指定主键的资源目录
resourceService.deleteResource(ids);
}
}
}

2
src/main/java/com/xmomen/module/resource/entity/Resource.java
Unescape View File

@ -1,4 +1,4 @@
package com.xmomen.module.resource.entity;
Xpackage com.xmomen.module.resource.entity;
import com.xmomen.framework.mybatis.model.BaseMybatisModel;
import javax.persistence.Column;

189
src/main/java/com/xmomen/module/resource/entity/mapper/ResourceMapper.xml
Unescape View File

@ -1,7 +1,15 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xmomen.module.resource.entity.mapper.ResourceMapper" >
<resultMap id="BaseResultMap" type="com.xmomen.module.resource.entity.Resource" >
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xmomen.module.resource.entity.mapper.ResourceMapper">
<!--
定义结果映射，将数据库查询结果映射到 Java 对象。
id: 结果映射的唯一标识。
type: 要映射的 Java 实体类的全限定名。
-->
<resultMap id="BaseResultMap" type="com.xmomen.module.resource.entity.Resource">
<!-- 映射数据库表中的主键列到实体类的属性 -->
<id column="ID" property="id" jdbcType="VARCHAR" />
<result column="ENTITY_TYPE" property="entityType" jdbcType="VARCHAR" />
<result column="ENTITY_ID" property="entityId" jdbcType="VARCHAR" />
@ -9,25 +17,37 @@
<result column="RESOURCE_TYPE" property="resourceType" jdbcType="VARCHAR" />
<result column="IS_DEFAULT" property="isDefault" jdbcType="INTEGER" />
</resultMap>
<sql id="Example_Where_Clause" >
<where >
<foreach collection="oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
<!--
定义 SQL 片段，用于生成 WHERE 子句。
此片段根据传入的查询条件动态生成 WHERE 子句，支持多种条件类型（无值、单值、范围值、列表值）。
-->
<sql id="Example_Where_Clause">
<where>
<!-- 遍历所有的查询条件组 -->
<foreach collection="oredCriteria" item="criteria" separator="or">
<if test="criteria.valid">
<!-- 去除开头多余的 "and" -->
<trim prefix="(" suffix=")" prefixOverrides="and">
<!-- 遍历每个查询条件组中的具体条件 -->
<foreach collection="criteria.criteria" item="criterion">
<choose>
<!-- 处理无值条件 -->
<when test="criterion.noValue">
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
<!-- 处理单值条件 -->
<when test="criterion.singleValue">
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
<!-- 处理范围值条件 -->
<when test="criterion.betweenValue">
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
<!-- 处理列表值条件 -->
<when test="criterion.listValue">
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
#{listItem}
</foreach>
</when>
@ -38,25 +58,30 @@
</foreach>
</where>
</sql>
<sql id="Update_By_Example_Where_Clause" >
<where >
<foreach collection="example.oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
<!--
定义 SQL 片段，用于生成 UPDATE 语句的 WHERE 子句。
逻辑与 Example_Where_Clause 类似，用于根据条件更新数据。
-->
<sql id="Update_By_Example_Where_Clause">
<where>
<foreach collection="example.oredCriteria" item="criteria" separator="or">
<if test="criteria.valid">
<trim prefix="(" suffix=")" prefixOverrides="and">
<foreach collection="criteria.criteria" item="criterion">
<choose>
<when test="criterion.noValue">
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
<when test="criterion.singleValue">
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
<when test="criterion.betweenValue">
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
<when test="criterion.listValue">
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
#{listItem}
</foreach>
</when>
@ -67,100 +92,148 @@
</foreach>
</where>
</sql>
<sql id="Base_Column_List" >
<!-- 定义 SQL 片段，列出表中的基本列名 -->
<sql id="Base_Column_List">
ID, ENTITY_TYPE, ENTITY_ID, PATH, RESOURCE_TYPE, IS_DEFAULT
</sql>
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.resource.entity.ResourceExample" >
<!--
定义查询语句，根据条件查询资源数据。
id: 语句的唯一标识。
resultMap: 引用前面定义的结果映射，用于将查询结果映射到实体类。
parameterType: 传入的参数类型，这里是查询条件对象。
-->
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.resource.entity.ResourceExample">
select
<if test="distinct" >
<!-- 如果需要去重，添加 distinct 关键字 -->
<if test="distinct">
distinct
</if>
<!-- 引入基本列名片段 -->
<include refid="Base_Column_List" />
from cd_resource
<if test="_parameter != null" >
<!-- 如果传入了查询参数，引入 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
<if test="orderByClause != null" >
<!-- 如果有排序条件，添加排序子句 -->
<if test="orderByClause != null">
order by ${orderByClause}
</if>
</select>
<delete id="deleteByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" >
<!--
定义删除语句，根据条件删除资源数据。
id: 语句的唯一标识。
parameterType: 传入的参数类型，这里是查询条件对象。
-->
<delete id="deleteByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample">
delete from cd_resource
<if test="_parameter != null" >
<!-- 如果传入了查询参数，引入 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</delete>
<insert id="insertSelective" parameterType="com.xmomen.module.resource.entity.Resource" useGeneratedKeys="true" keyProperty="id" keyColumn="ID" >
<selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE" >
<!--
定义插入语句，选择性插入资源数据（只插入非空字段）。
id: 语句的唯一标识。
parameterType: 传入的参数类型，这里是要插入的实体类对象。
useGeneratedKeys: 是否使用数据库生成的主键。
keyProperty: 实体类中表示主键的属性名。
keyColumn: 数据库表中主键列的名称。
-->
<insert id="insertSelective" parameterType="com.xmomen.module.resource.entity.Resource" useGeneratedKeys="true" keyProperty="id" keyColumn="ID">
<!-- 在插入前生成主键值，这里使用 UUID 并去除连字符 -->
<selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE">
SELECT replace(UUID(),'-','')
</selectKey>
insert into cd_resource
<trim prefix="(" suffix=")" suffixOverrides="," >
<!-- 动态生成插入的列名，只包含非空字段 -->
<trim prefix="(" suffix=")" suffixOverrides=",">
ID,
<if test="entityType != null" >
<if test="entityType != null">
ENTITY_TYPE,
</if>
<if test="entityId != null" >
<if test="entityId != null">
ENTITY_ID,
</if>
<if test="path != null" >
<if test="path != null">
PATH,
</if>
<if test="resourceType != null" >
<if test="resourceType != null">
RESOURCE_TYPE,
</if>
<if test="isDefault != null" >
<if test="isDefault != null">
IS_DEFAULT,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<!-- 动态生成插入的值，只包含非空字段 -->
<trim prefix="values (" suffix=")" suffixOverrides=",">
#{id,jdbcType=VARCHAR},
<if test="entityType != null" >
<if test="entityType != null">
#{entityType,jdbcType=VARCHAR},
</if>
<if test="entityId != null" >
<if test="entityId != null">
#{entityId,jdbcType=VARCHAR},
</if>
<if test="path != null" >
<if test="path != null">
#{path,jdbcType=VARCHAR},
</if>
<if test="resourceType != null" >
<if test="resourceType != null">
#{resourceType,jdbcType=VARCHAR},
</if>
<if test="isDefault != null" >
<if test="isDefault != null">
#{isDefault,jdbcType=INTEGER},
</if>
</trim>
</insert>
<select id="countByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" resultType="java.lang.Integer" >
<!--
定义统计语句，根据条件统计资源数据的数量。
id: 语句的唯一标识。
parameterType: 传入的参数类型，这里是查询条件对象。
resultType: 返回的结果类型，这里是整数类型。
-->
<select id="countByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" resultType="java.lang.Integer">
select count(*) from cd_resource
<if test="_parameter != null" >
<!-- 如果传入了查询参数，引入 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</select>
<update id="updateByExampleSelective" parameterType="map" >
<!--
定义更新语句，根据条件选择性更新资源数据（只更新非空字段）。
id: 语句的唯一标识。
parameterType: 传入的参数类型，这里是一个包含实体类对象和查询条件的 Map。
-->
<update id="updateByExampleSelective" parameterType="map">
update cd_resource
<set >
<if test="record.id != null" >
<!-- 动态生成 SET 子句，只包含非空字段 -->
<set>
<if test="record.id != null">
ID = #{record.id,jdbcType=VARCHAR},
</if>
<if test="record.entityType != null" >
<if test="record.entityType != null">
ENTITY_TYPE = #{record.entityType,jdbcType=VARCHAR},
</if>
<if test="record.entityId != null" >
<if test="record.entityId != null">
ENTITY_ID = #{record.entityId,jdbcType=VARCHAR},
</if>
<if test="record.path != null" >
<if test="record.path != null">
PATH = #{record.path,jdbcType=VARCHAR},
</if>
<if test="record.resourceType != null" >
<if test="record.resourceType != null">
RESOURCE_TYPE = #{record.resourceType,jdbcType=VARCHAR},
</if>
<if test="record.isDefault != null" >
<if test="record.isDefault != null">
IS_DEFAULT = #{record.isDefault,jdbcType=INTEGER},
</if>
</set>
<if test="_parameter != null" >
<!-- 如果传入了查询参数，引入 UPDATE 的 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>

61
src/main/java/org/csource/fastdfs/ClientGlobal.java
Unescape View File

@ -1,11 +1,3 @@
/**
* Copyright (C) 2008 Happy Fish / YuQing
*
* FastDFS Java Client may be copied only under the terms of the GNU Lesser
* General Public License (LGPL).
* Please visit the FastDFS Home Page http://www.csource.org/ for more detail.
**/
package org.csource.fastdfs;
import java.net.*;
@ -13,11 +5,6 @@ import java.io.*;
import java.net.*;
import org.csource.common.*;
/**
* Global variables
* @author Happy Fish / YuQing
* @version Version 1.11
*/
public class ClientGlobal
{
public static int g_connect_timeout; //millisecond
@ -27,18 +14,14 @@ public class ClientGlobal
public static boolean g_anti_steal_token; //if anti-steal token
public static String g_secret_key; //generage token secret key
public static TrackerGroup g_tracker_group;
public static final int DEFAULT_CONNECT_TIMEOUT = 5; //second
public static final int DEFAULT_NETWORK_TIMEOUT = 30; //second
private ClientGlobal()
{
}
/**
* load global variables
* @param conf_filename config filename
*/
// 初始化ClientGlobal
public static void init(String conf_filename) throws FileNotFoundException, IOException, MyException
{
IniFileReader iniReader;
@ -47,6 +30,7 @@ public class ClientGlobal
iniReader = new IniFileReader(conf_filename);
// 读取连接超时时间
g_connect_timeout = iniReader.getIntValue("connect_timeout", DEFAULT_CONNECT_TIMEOUT);
if (g_connect_timeout < 0)
{
@ -54,6 +38,7 @@ public class ClientGlobal
}
g_connect_timeout *= 1000; //millisecond
// 读取网络超时时间
g_network_timeout = iniReader.getIntValue("network_timeout", DEFAULT_NETWORK_TIMEOUT);
if (g_network_timeout < 0)
{
@ -61,18 +46,21 @@ public class ClientGlobal
}
g_network_timeout *= 1000; //millisecond
// 读取字符集
g_charset = iniReader.getStrValue("charset");
if (g_charset == null || g_charset.length() == 0)
{
g_charset = "ISO8859-1";
}
// 读取tracker服务器地址
szTrackerServers = iniReader.getValues("tracker_server");
if (szTrackerServers == null)
{
throw new MyException("item \"tracker_server\" in " + conf_filename + " not found");
}
// 将tracker服务器地址转换为InetSocketAddress数组
InetSocketAddress[] tracker_servers = new InetSocketAddress[szTrackerServers.length];
for (int i=0; i<szTrackerServers.length; i++)
{
@ -86,20 +74,18 @@ public class ClientGlobal
}
g_tracker_group = new TrackerGroup(tracker_servers);
// 读取tracker服务器HTTP端口
g_tracker_http_port = iniReader.getIntValue("http.tracker_http_port", 80);
// 读取是否启用反盗链
g_anti_steal_token = iniReader.getBoolValue("http.anti_steal_token", false);
if (g_anti_steal_token)
{
// 读取反盗链密钥
g_secret_key = iniReader.getStrValue("http.secret_key");
}
}
/**
* construct Socket object
* @param ip_addr ip address or hostname
* @param port port number
* @return connected Socket object
*/
// 根据IP地址和端口获取Socket
public static Socket getSocket(String ip_addr, int port) throws IOException
{
Socket sock = new Socket();
@ -107,12 +93,8 @@ public class ClientGlobal
sock.connect(new InetSocketAddress(ip_addr, port), ClientGlobal.g_connect_timeout);
return sock;
}
/**
* construct Socket object
* @param addr InetSocketAddress object, including ip address and port
* @return connected Socket object
*/
// 根据InetSocketAddress获取Socket
public static Socket getSocket(InetSocketAddress addr) throws IOException
{
Socket sock = new Socket();
@ -121,76 +103,91 @@ public class ClientGlobal
return sock;
}
// 获取连接超时时间
public static int getG_connect_timeout()
{
return g_connect_timeout;
}
// 设置连接超时时间
public static void setG_connect_timeout(int connect_timeout)
{
ClientGlobal.g_connect_timeout = connect_timeout;
}
// 获取网络超时时间
public static int getG_network_timeout()
{
return g_network_timeout;
}
// 设置网络超时时间
public static void setG_network_timeout(int network_timeout)
{
ClientGlobal.g_network_timeout = network_timeout;
}
// 获取字符集
public static String getG_charset()
{
return g_charset;
}
// 设置字符集
public static void setG_charset(String charset)
{
ClientGlobal.g_charset = charset;
}
// 获取tracker服务器HTTP端口
public static int getG_tracker_http_port()
{
return g_tracker_http_port;
}
// 设置tracker服务器HTTP端口
public static void setG_tracker_http_port(int tracker_http_port)
{
ClientGlobal.g_tracker_http_port = tracker_http_port;
}
// 获取是否启用反盗链
public static boolean getG_anti_steal_token()
{
return g_anti_steal_token;
}
// 获取是否启用反盗链
public static boolean isG_anti_steal_token()
{
return g_anti_steal_token;
}
// 设置是否启用反盗链
public static void setG_anti_steal_token(boolean anti_steal_token)
{
ClientGlobal.g_anti_steal_token = anti_steal_token;
}
// 获取反盗链密钥
public static String getG_secret_key()
{
return g_secret_key;
}
// 设置反盗链密钥
public static void setG_secret_key(String secret_key)
{
ClientGlobal.g_secret_key = secret_key;
}
// 获取tracker服务器组
public static TrackerGroup getG_tracker_group()
{
return g_tracker_group;
}
// 设置tracker服务器组
public static void setG_tracker_group(TrackerGroup tracker_group)
{
ClientGlobal.g_tracker_group = tracker_group;

19
src/main/java/org/csource/fastdfs/DownloadStream.java
Unescape View File

@ -4,33 +4,26 @@ import java.io.IOException;
import java.io.OutputStream;
import org.csource.fastdfs.DownloadCallback;
/**
* Download file by stream (download callback class)
* @author zhouzezhong & Happy Fish / YuQing
* @version Version 1.11
*/
public class DownloadStream implements DownloadCallback
{
// 定义输出流
private OutputStream out;
// 定义当前字节
private long currentBytes = 0;
// 构造函数，传入输出流
public DownloadStream(OutputStream out)
{
super();
this.out = out;
}
/**
* recv file content callback function, may be called more than once when the file downloaded
* @param fileSize file size
* @param data data buff
* @param bytes data bytes
* @return 0 success, return none zero(errno) if fail
*/
public int recv(long fileSize, byte[] data, int bytes)
{
try
{
// 将数据写入输出流
out.write(data, 0, bytes);
}
catch(IOException ex)
@ -39,7 +32,9 @@ public class DownloadStream implements DownloadCallback
return -1;
}
// 更新当前字节
currentBytes += bytes;
// 如果当前字节等于文件大小，则重置当前字节
if (this.currentBytes == fileSize)
{
this.currentBytes = 0;

6
src/main/webapp/doc/swagger-ui/dist/index.html vendored
Unescape View File

@ -5,12 +5,14 @@
<title>Swagger UI</title>
<link rel="icon" type="image/png" href="images/favicon-32x32.png" sizes="32x32" />
<link rel="icon" type="image/png" href="images/favicon-16x16.png" sizes="16x16" />
<!-- 引入样式文件 -->
<link href='css/typography.css' media='screen' rel='stylesheet' type='text/css'/>
<link href='css/reset.css' media='screen' rel='stylesheet' type='text/css'/>
<link href='css/screen.css' media='screen' rel='stylesheet' type='text/css'/>
<link href='css/reset.css' media='print' rel='stylesheet' type='text/css'/>
<link href='css/print.css' media='print' rel='stylesheet' type='text/css'/>
<!-- 引入脚本文件 -->
<script src='lib/object-assign-pollyfill.js' type='text/javascript'></script>
<script src='lib/jquery-1.8.0.min.js' type='text/javascript'></script>
<script src='lib/jquery.slideto.min.js' type='text/javascript'></script>
@ -33,6 +35,7 @@
<script type="text/javascript">
$(function () {
// 获取url参数
var url = window.location.search.match(/url=([^&]+)/);
if (url && url.length > 1) {
url = decodeURIComponent(url[1]);
@ -40,6 +43,7 @@
url = "/api-docs/";
}
// 配置highlight.js
hljs.configure({
highlightSizeThreshold: 5000
});
@ -53,6 +57,7 @@
dom_id: "swagger-ui-container",
supportedSubmitMethods: ['get', 'post', 'put', 'delete', 'patch'],
onComplete: function(swaggerApi, swaggerUi){
// 初始化OAuth
if(typeof initOAuth == "function") {
initOAuth({
clientId: "your-client-id",
@ -64,6 +69,7 @@
});
}
// 翻译
if(window.SwaggerTranslator) {
window.SwaggerTranslator.translate();
}

Write Preview
Loading…
Cancel
Save