111

k94314517

2025-07-09 25cb0f0f45a563f2249eec15b0887a58ff7482a0

111

 server/src/main/java/com/doumee/api/business/CategoryController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.Category;
import com.doumee.service.business.CategoryService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "分类信息表")
@RestController
@RequestMapping("/business/category")
public class CategoryController extends BaseController {

    @Autowired
    private CategoryService categoryService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:category:create")
    public ApiResponse create(@RequestBody Category category) {
        return ApiResponse.success(categoryService.create(category));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:category:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        categoryService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:category:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        categoryService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:category:update")
    public ApiResponse updateById(@RequestBody Category category) {
        categoryService.updateById(category);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:category:query")
    public ApiResponse<PageData<Category>> findPage (@RequestBody PageWrap<Category> pageWrap) {
        return ApiResponse.success(categoryService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:category:exportExcel")
    public void exportExcel (@RequestBody PageWrap<Category> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(Category.class).export(categoryService.findPage(pageWrap).getRecords(), "分类信息表", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:category:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(categoryService.findById(id));
    }
}

 server/src/main/java/com/doumee/api/business/IdentityInfoController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.IdentityInfo;
import com.doumee.service.business.IdentityInfoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "会员身份认证信息表")
@RestController
@RequestMapping("/business/identityInfo")
public class IdentityInfoController extends BaseController {

    @Autowired
    private IdentityInfoService identityInfoService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:identityinfo:create")
    public ApiResponse create(@RequestBody IdentityInfo identityInfo) {
        return ApiResponse.success(identityInfoService.create(identityInfo));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:identityinfo:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        identityInfoService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:identityinfo:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        identityInfoService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:identityinfo:update")
    public ApiResponse updateById(@RequestBody IdentityInfo identityInfo) {
        identityInfoService.updateById(identityInfo);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:identityinfo:query")
    public ApiResponse<PageData<IdentityInfo>> findPage (@RequestBody PageWrap<IdentityInfo> pageWrap) {
        return ApiResponse.success(identityInfoService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:identityinfo:exportExcel")
    public void exportExcel (@RequestBody PageWrap<IdentityInfo> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(IdentityInfo.class).export(identityInfoService.findPage(pageWrap).getRecords(), "会员身份认证信息表", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:identityinfo:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(identityInfoService.findById(id));
    }
}

 server/src/main/java/com/doumee/api/business/MemberController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.Member;
import com.doumee.service.business.MemberService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "会员信息表")
@RestController
@RequestMapping("/business/member")
public class MemberController extends BaseController {

    @Autowired
    private MemberService memberService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:member:create")
    public ApiResponse create(@RequestBody Member member) {
        return ApiResponse.success(memberService.create(member));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:member:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        memberService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:member:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        memberService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:member:update")
    public ApiResponse updateById(@RequestBody Member member) {
        memberService.updateById(member);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:member:query")
    public ApiResponse<PageData<Member>> findPage (@RequestBody PageWrap<Member> pageWrap) {
        return ApiResponse.success(memberService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:member:exportExcel")
    public void exportExcel (@RequestBody PageWrap<Member> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(Member.class).export(memberService.findPage(pageWrap).getRecords(), "会员信息表", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:member:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(memberService.findById(id));
    }
}

 server/src/main/java/com/doumee/api/business/MemberRevenueController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.MemberRevenue;
import com.doumee.service.business.MemberRevenueService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "会员收支记录")
@RestController
@RequestMapping("/business/memberRevenue")
public class MemberRevenueController extends BaseController {

    @Autowired
    private MemberRevenueService memberRevenueService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:memberrevenue:create")
    public ApiResponse create(@RequestBody MemberRevenue memberRevenue) {
        return ApiResponse.success(memberRevenueService.create(memberRevenue));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:memberrevenue:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        memberRevenueService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:memberrevenue:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        memberRevenueService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:memberrevenue:update")
    public ApiResponse updateById(@RequestBody MemberRevenue memberRevenue) {
        memberRevenueService.updateById(memberRevenue);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:memberrevenue:query")
    public ApiResponse<PageData<MemberRevenue>> findPage (@RequestBody PageWrap<MemberRevenue> pageWrap) {
        return ApiResponse.success(memberRevenueService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:memberrevenue:exportExcel")
    public void exportExcel (@RequestBody PageWrap<MemberRevenue> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(MemberRevenue.class).export(memberRevenueService.findPage(pageWrap).getRecords(), "会员收支记录", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:memberrevenue:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(memberRevenueService.findById(id));
    }
}

 server/src/main/java/com/doumee/api/business/OrderLogController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.OrderLog;
import com.doumee.service.business.OrderLogService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "订单操作日志")
@RestController
@RequestMapping("/business/orderLog")
public class OrderLogController extends BaseController {

    @Autowired
    private OrderLogService orderLogService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:orderlog:create")
    public ApiResponse create(@RequestBody OrderLog orderLog) {
        return ApiResponse.success(orderLogService.create(orderLog));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:orderlog:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        orderLogService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:orderlog:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        orderLogService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:orderlog:update")
    public ApiResponse updateById(@RequestBody OrderLog orderLog) {
        orderLogService.updateById(orderLog);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:orderlog:query")
    public ApiResponse<PageData<OrderLog>> findPage (@RequestBody PageWrap<OrderLog> pageWrap) {
        return ApiResponse.success(orderLogService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:orderlog:exportExcel")
    public void exportExcel (@RequestBody PageWrap<OrderLog> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(OrderLog.class).export(orderLogService.findPage(pageWrap).getRecords(), "订单操作日志", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:orderlog:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(orderLogService.findById(id));
    }
}

 server/src/main/java/com/doumee/api/business/OrdersController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.Orders;
import com.doumee.service.business.OrdersService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "订单信息记录")
@RestController
@RequestMapping("/business/orders")
public class OrdersController extends BaseController {

    @Autowired
    private OrdersService ordersService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:orders:create")
    public ApiResponse create(@RequestBody Orders orders) {
        return ApiResponse.success(ordersService.create(orders));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:orders:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        ordersService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:orders:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        ordersService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:orders:update")
    public ApiResponse updateById(@RequestBody Orders orders) {
        ordersService.updateById(orders);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:orders:query")
    public ApiResponse<PageData<Orders>> findPage (@RequestBody PageWrap<Orders> pageWrap) {
        return ApiResponse.success(ordersService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:orders:exportExcel")
    public void exportExcel (@RequestBody PageWrap<Orders> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(Orders.class).export(ordersService.findPage(pageWrap).getRecords(), "订单信息记录", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:orders:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(ordersService.findById(id));
    }
}

 server/src/main/java/com/doumee/api/business/ReceiveWeightController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.ReceiveWeight;
import com.doumee.service.business.ReceiveWeightService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "接单权重配置表")
@RestController
@RequestMapping("/business/receiveWeight")
public class ReceiveWeightController extends BaseController {

    @Autowired
    private ReceiveWeightService receiveWeightService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:receiveweight:create")
    public ApiResponse create(@RequestBody ReceiveWeight receiveWeight) {
        return ApiResponse.success(receiveWeightService.create(receiveWeight));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:receiveweight:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        receiveWeightService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:receiveweight:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        receiveWeightService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:receiveweight:update")
    public ApiResponse updateById(@RequestBody ReceiveWeight receiveWeight) {
        receiveWeightService.updateById(receiveWeight);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:receiveweight:query")
    public ApiResponse<PageData<ReceiveWeight>> findPage (@RequestBody PageWrap<ReceiveWeight> pageWrap) {
        return ApiResponse.success(receiveWeightService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:receiveweight:exportExcel")
    public void exportExcel (@RequestBody PageWrap<ReceiveWeight> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(ReceiveWeight.class).export(receiveWeightService.findPage(pageWrap).getRecords(), "接单权重配置表", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:receiveweight:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(receiveWeightService.findById(id));
    }
}

 server/src/main/java/com/doumee/api/business/WithdrawalOrdersController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
package com.doumee.api.business;

import com.doumee.api.BaseController;
import com.doumee.core.annotation.excel.ExcelExporter;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.model.ApiResponse;
import com.doumee.core.model.PageWrap;
import com.doumee.core.model.PageData;
import com.doumee.dao.business.model.WithdrawalOrders;
import com.doumee.service.business.WithdrawalOrdersService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;    
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Api(tags = "提现申请记录")
@RestController
@RequestMapping("/business/withdrawalOrders")
public class WithdrawalOrdersController extends BaseController {

    @Autowired
    private WithdrawalOrdersService withdrawalOrdersService;

    @PreventRepeat
    @ApiOperation("新建")
    @PostMapping("/create")
    @RequiresPermissions("business:withdrawalorders:create")
    public ApiResponse create(@RequestBody WithdrawalOrders withdrawalOrders) {
        return ApiResponse.success(withdrawalOrdersService.create(withdrawalOrders));
    }

    @ApiOperation("根据ID删除")
    @GetMapping("/delete/{id}")
    @RequiresPermissions("business:withdrawalorders:delete")
    public ApiResponse deleteById(@PathVariable Integer id) {
        withdrawalOrdersService.deleteById(id);
        return ApiResponse.success(null);
    }

    @ApiOperation("批量删除")
    @GetMapping("/delete/batch")
    @RequiresPermissions("business:withdrawalorders:delete")
    public ApiResponse deleteByIdInBatch(@RequestParam String ids) {
        String [] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        withdrawalOrdersService.deleteByIdInBatch(idList);
        return ApiResponse.success(null);
    }

    @ApiOperation("根据ID修改")
    @PostMapping("/updateById")
    @RequiresPermissions("business:withdrawalorders:update")
    public ApiResponse updateById(@RequestBody WithdrawalOrders withdrawalOrders) {
        withdrawalOrdersService.updateById(withdrawalOrders);
        return ApiResponse.success(null);
    }

    @ApiOperation("分页查询")
    @PostMapping("/page")
    @RequiresPermissions("business:withdrawalorders:query")
    public ApiResponse<PageData<WithdrawalOrders>> findPage (@RequestBody PageWrap<WithdrawalOrders> pageWrap) {
        return ApiResponse.success(withdrawalOrdersService.findPage(pageWrap));
    }

    @ApiOperation("导出Excel")
    @PostMapping("/exportExcel")
    @RequiresPermissions("business:withdrawalorders:exportExcel")
    public void exportExcel (@RequestBody PageWrap<WithdrawalOrders> pageWrap, HttpServletResponse response) {
        ExcelExporter.build(WithdrawalOrders.class).export(withdrawalOrdersService.findPage(pageWrap).getRecords(), "提现申请记录", response);
    }

    @ApiOperation("根据ID查询")
    @GetMapping("/{id}")
    @RequiresPermissions("business:withdrawalorders:query")
    public ApiResponse findById(@PathVariable Integer id) {
        return ApiResponse.success(withdrawalOrdersService.findById(id));
    }
}

 server/src/main/java/com/doumee/dao/business/CategoryMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.Category;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface CategoryMapper extends BaseMapper<Category> {

}

 server/src/main/java/com/doumee/dao/business/IdentityInfoMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.IdentityInfo;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface IdentityInfoMapper extends BaseMapper<IdentityInfo> {

}

 server/src/main/java/com/doumee/dao/business/MemberMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.Member;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface MemberMapper extends BaseMapper<Member> {

}

 server/src/main/java/com/doumee/dao/business/MemberRevenueMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.MemberRevenue;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface MemberRevenueMapper extends BaseMapper<MemberRevenue> {

}

 server/src/main/java/com/doumee/dao/business/OrderLogMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.OrderLog;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface OrderLogMapper extends BaseMapper<OrderLog> {

}

 server/src/main/java/com/doumee/dao/business/OrdersMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.Orders;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface OrdersMapper extends BaseMapper<Orders> {

}

 server/src/main/java/com/doumee/dao/business/ReceiveWeightMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.ReceiveWeight;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface ReceiveWeightMapper extends BaseMapper<ReceiveWeight> {

}

 server/src/main/java/com/doumee/dao/business/WithdrawalOrdersMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.doumee.dao.business;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumee.dao.business.model.WithdrawalOrders;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface WithdrawalOrdersMapper extends BaseMapper<WithdrawalOrders> {

}

 server/src/main/java/com/doumee/service/business/CategoryService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.Category;
import java.util.List;

/**
 * åˆ†ç±»ä¿¡æ¯è¡¨Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface CategoryService {

    /**
     * åˆ›å»º
     * 
     * @param category å®žä½“对象
     * @return Integer
     */
    Integer create(Category category);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param category å®žä½“对象
     */
    void delete(Category category);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param category å®žä½“对象
     */
    void updateById(Category category);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param categorys å®žä½“集
     */
    void updateByIdInBatch(List<Category> categorys);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return Category
     */
    Category findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param category å®žä½“对象
     * @return Category
     */
    Category findOne(Category category);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param category å®žä½“对象
     * @return List<Category>
     */
    List<Category> findList(Category category);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<Category>
     */
    PageData<Category> findPage(PageWrap<Category> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param category å®žä½“对象
     * @return long
     */
    long count(Category category);
}

 server/src/main/java/com/doumee/service/business/IdentityInfoService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.IdentityInfo;
import java.util.List;

/**
 * ä¼šå‘˜èº«ä»½è®¤è¯ä¿¡æ¯è¡¨Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface IdentityInfoService {

    /**
     * åˆ›å»º
     * 
     * @param identityInfo å®žä½“对象
     * @return Integer
     */
    Integer create(IdentityInfo identityInfo);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param identityInfo å®žä½“对象
     */
    void delete(IdentityInfo identityInfo);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param identityInfo å®žä½“对象
     */
    void updateById(IdentityInfo identityInfo);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param identityInfos å®žä½“集
     */
    void updateByIdInBatch(List<IdentityInfo> identityInfos);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return IdentityInfo
     */
    IdentityInfo findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param identityInfo å®žä½“对象
     * @return IdentityInfo
     */
    IdentityInfo findOne(IdentityInfo identityInfo);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param identityInfo å®žä½“对象
     * @return List<IdentityInfo>
     */
    List<IdentityInfo> findList(IdentityInfo identityInfo);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<IdentityInfo>
     */
    PageData<IdentityInfo> findPage(PageWrap<IdentityInfo> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param identityInfo å®žä½“对象
     * @return long
     */
    long count(IdentityInfo identityInfo);
}

 server/src/main/java/com/doumee/service/business/MemberRevenueService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.MemberRevenue;
import java.util.List;

/**
 * ä¼šå‘˜æ”¶æ”¯è®°å½•Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface MemberRevenueService {

    /**
     * åˆ›å»º
     * 
     * @param memberRevenue å®žä½“对象
     * @return Integer
     */
    Integer create(MemberRevenue memberRevenue);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param memberRevenue å®žä½“对象
     */
    void delete(MemberRevenue memberRevenue);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param memberRevenue å®žä½“对象
     */
    void updateById(MemberRevenue memberRevenue);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param memberRevenues å®žä½“集
     */
    void updateByIdInBatch(List<MemberRevenue> memberRevenues);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return MemberRevenue
     */
    MemberRevenue findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param memberRevenue å®žä½“对象
     * @return MemberRevenue
     */
    MemberRevenue findOne(MemberRevenue memberRevenue);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param memberRevenue å®žä½“对象
     * @return List<MemberRevenue>
     */
    List<MemberRevenue> findList(MemberRevenue memberRevenue);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<MemberRevenue>
     */
    PageData<MemberRevenue> findPage(PageWrap<MemberRevenue> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param memberRevenue å®žä½“对象
     * @return long
     */
    long count(MemberRevenue memberRevenue);
}

 server/src/main/java/com/doumee/service/business/MemberService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.Member;
import java.util.List;

/**
 * ä¼šå‘˜ä¿¡æ¯è¡¨Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface MemberService {

    /**
     * åˆ›å»º
     * 
     * @param member å®žä½“对象
     * @return Integer
     */
    Integer create(Member member);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param member å®žä½“对象
     */
    void delete(Member member);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param member å®žä½“对象
     */
    void updateById(Member member);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param members å®žä½“集
     */
    void updateByIdInBatch(List<Member> members);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return Member
     */
    Member findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param member å®žä½“对象
     * @return Member
     */
    Member findOne(Member member);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param member å®žä½“对象
     * @return List<Member>
     */
    List<Member> findList(Member member);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<Member>
     */
    PageData<Member> findPage(PageWrap<Member> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param member å®žä½“对象
     * @return long
     */
    long count(Member member);
}

 server/src/main/java/com/doumee/service/business/OrderLogService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.OrderLog;
import java.util.List;

/**
 * è®¢å•æ“ä½œæ—¥å¿—Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface OrderLogService {

    /**
     * åˆ›å»º
     * 
     * @param orderLog å®žä½“对象
     * @return Integer
     */
    Integer create(OrderLog orderLog);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param orderLog å®žä½“对象
     */
    void delete(OrderLog orderLog);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param orderLog å®žä½“对象
     */
    void updateById(OrderLog orderLog);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param orderLogs å®žä½“集
     */
    void updateByIdInBatch(List<OrderLog> orderLogs);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return OrderLog
     */
    OrderLog findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param orderLog å®žä½“对象
     * @return OrderLog
     */
    OrderLog findOne(OrderLog orderLog);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param orderLog å®žä½“对象
     * @return List<OrderLog>
     */
    List<OrderLog> findList(OrderLog orderLog);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<OrderLog>
     */
    PageData<OrderLog> findPage(PageWrap<OrderLog> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param orderLog å®žä½“对象
     * @return long
     */
    long count(OrderLog orderLog);
}

 server/src/main/java/com/doumee/service/business/OrdersService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.Orders;
import java.util.List;

/**
 * è®¢å•ä¿¡æ¯è®°å½•Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface OrdersService {

    /**
     * åˆ›å»º
     * 
     * @param orders å®žä½“对象
     * @return Integer
     */
    Integer create(Orders orders);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param orders å®žä½“对象
     */
    void delete(Orders orders);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param orders å®žä½“对象
     */
    void updateById(Orders orders);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param orderss å®žä½“集
     */
    void updateByIdInBatch(List<Orders> orderss);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return Orders
     */
    Orders findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param orders å®žä½“对象
     * @return Orders
     */
    Orders findOne(Orders orders);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param orders å®žä½“对象
     * @return List<Orders>
     */
    List<Orders> findList(Orders orders);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<Orders>
     */
    PageData<Orders> findPage(PageWrap<Orders> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param orders å®žä½“对象
     * @return long
     */
    long count(Orders orders);
}

 server/src/main/java/com/doumee/service/business/ReceiveWeightService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.ReceiveWeight;
import java.util.List;

/**
 * æŽ¥å•æƒé‡é…ç½®è¡¨Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface ReceiveWeightService {

    /**
     * åˆ›å»º
     * 
     * @param receiveWeight å®žä½“对象
     * @return Integer
     */
    Integer create(ReceiveWeight receiveWeight);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param receiveWeight å®žä½“对象
     */
    void delete(ReceiveWeight receiveWeight);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param receiveWeight å®žä½“对象
     */
    void updateById(ReceiveWeight receiveWeight);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param receiveWeights å®žä½“集
     */
    void updateByIdInBatch(List<ReceiveWeight> receiveWeights);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return ReceiveWeight
     */
    ReceiveWeight findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param receiveWeight å®žä½“对象
     * @return ReceiveWeight
     */
    ReceiveWeight findOne(ReceiveWeight receiveWeight);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param receiveWeight å®žä½“对象
     * @return List<ReceiveWeight>
     */
    List<ReceiveWeight> findList(ReceiveWeight receiveWeight);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<ReceiveWeight>
     */
    PageData<ReceiveWeight> findPage(PageWrap<ReceiveWeight> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param receiveWeight å®žä½“对象
     * @return long
     */
    long count(ReceiveWeight receiveWeight);
}

 server/src/main/java/com/doumee/service/business/WithdrawalOrdersService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
package com.doumee.service.business;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.model.WithdrawalOrders;
import java.util.List;

/**
 * æçŽ°ç”³è¯·è®°å½•Service定义
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
public interface WithdrawalOrdersService {

    /**
     * åˆ›å»º
     * 
     * @param withdrawalOrders å®žä½“对象
     * @return Integer
     */
    Integer create(WithdrawalOrders withdrawalOrders);

    /**
     * ä¸»é”®åˆ é™¤
     *
     * @param id ä¸»é”®
     */
    void deleteById(Integer id);

    /**
     * åˆ é™¤
     *
     * @param withdrawalOrders å®žä½“对象
     */
    void delete(WithdrawalOrders withdrawalOrders);

    /**
     * æ‰¹é‡ä¸»é”®åˆ é™¤
     *
     * @param ids ä¸»é”®é›†
     */
    void deleteByIdInBatch(List<Integer> ids);

    /**
     * ä¸»é”®æ›´æ–°
     *
     * @param withdrawalOrders å®žä½“对象
     */
    void updateById(WithdrawalOrders withdrawalOrders);

    /**
     * æ‰¹é‡ä¸»é”®æ›´æ–°
     *
     * @param withdrawalOrderss å®žä½“集
     */
    void updateByIdInBatch(List<WithdrawalOrders> withdrawalOrderss);

    /**
     * ä¸»é”®æŸ¥è¯¢
     *
     * @param id ä¸»é”®
     * @return WithdrawalOrders
     */
    WithdrawalOrders findById(Integer id);

    /**
     * æ¡ä»¶æŸ¥è¯¢å•æ¡è®°å½•
     *
     * @param withdrawalOrders å®žä½“对象
     * @return WithdrawalOrders
     */
    WithdrawalOrders findOne(WithdrawalOrders withdrawalOrders);

    /**
     * æ¡ä»¶æŸ¥è¯¢
     *
     * @param withdrawalOrders å®žä½“对象
     * @return List<WithdrawalOrders>
     */
    List<WithdrawalOrders> findList(WithdrawalOrders withdrawalOrders);
  
    /**
     * åˆ†é¡µæŸ¥è¯¢
     *
     * @param pageWrap åˆ†é¡µå¯¹è±¡
     * @return PageData<WithdrawalOrders>
     */
    PageData<WithdrawalOrders> findPage(PageWrap<WithdrawalOrders> pageWrap);

    /**
     * æ¡ä»¶ç»Ÿè®¡
     *
     * @param withdrawalOrders å®žä½“对象
     * @return long
     */
    long count(WithdrawalOrders withdrawalOrders);
}

 server/src/main/java/com/doumee/service/business/impl/CategoryServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,148 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.CategoryMapper;
import com.doumee.dao.business.model.Category;
import com.doumee.service.business.CategoryService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * åˆ†ç±»ä¿¡æ¯è¡¨Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class CategoryServiceImpl implements CategoryService {

    @Autowired
    private CategoryMapper categoryMapper;

    @Override
    public Integer create(Category category) {
        categoryMapper.insert(category);
        return category.getId();
    }

    @Override
    public void deleteById(Integer id) {
        categoryMapper.deleteById(id);
    }

    @Override
    public void delete(Category category) {
        UpdateWrapper<Category> deleteWrapper = new UpdateWrapper<>(category);
        categoryMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        categoryMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(Category category) {
        categoryMapper.updateById(category);
    }

    @Override
    public void updateByIdInBatch(List<Category> categorys) {
        if (CollectionUtils.isEmpty(categorys)) {
            return;
        }
        for (Category category: categorys) {
            this.updateById(category);
        }
    }

    @Override
    public Category findById(Integer id) {
        return categoryMapper.selectById(id);
    }

    @Override
    public Category findOne(Category category) {
        QueryWrapper<Category> wrapper = new QueryWrapper<>(category);
        return categoryMapper.selectOne(wrapper);
    }

    @Override
    public List<Category> findList(Category category) {
        QueryWrapper<Category> wrapper = new QueryWrapper<>(category);
        return categoryMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<Category> findPage(PageWrap<Category> pageWrap) {
        IPage<Category> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<Category> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(Category::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(Category::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(Category::getStatus, pageWrap.getModel().getStatus());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(Category::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(Category::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(Category::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(Category::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(Category::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(Category::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(Category::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getName() != null) {
            queryWrapper.lambda().eq(Category::getName, pageWrap.getModel().getName());
        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.lambda().eq(Category::getType, pageWrap.getModel().getType());
        }
        if (pageWrap.getModel().getDetail() != null) {
            queryWrapper.lambda().eq(Category::getDetail, pageWrap.getModel().getDetail());
        }
        if (pageWrap.getModel().getIcon() != null) {
            queryWrapper.lambda().eq(Category::getIcon, pageWrap.getModel().getIcon());
        }
        if (pageWrap.getModel().getIsFixed() != null) {
            queryWrapper.lambda().eq(Category::getIsFixed, pageWrap.getModel().getIsFixed());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(categoryMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(Category category) {
        QueryWrapper<Category> wrapper = new QueryWrapper<>(category);
        return categoryMapper.selectCount(wrapper);
    }
}

 server/src/main/java/com/doumee/service/business/impl/IdentityInfoServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,188 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.IdentityInfoMapper;
import com.doumee.dao.business.model.IdentityInfo;
import com.doumee.service.business.IdentityInfoService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * ä¼šå‘˜èº«ä»½è®¤è¯ä¿¡æ¯è¡¨Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class IdentityInfoServiceImpl implements IdentityInfoService {

    @Autowired
    private IdentityInfoMapper identityInfoMapper;

    @Override
    public Integer create(IdentityInfo identityInfo) {
        identityInfoMapper.insert(identityInfo);
        return identityInfo.getId();
    }

    @Override
    public void deleteById(Integer id) {
        identityInfoMapper.deleteById(id);
    }

    @Override
    public void delete(IdentityInfo identityInfo) {
        UpdateWrapper<IdentityInfo> deleteWrapper = new UpdateWrapper<>(identityInfo);
        identityInfoMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        identityInfoMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(IdentityInfo identityInfo) {
        identityInfoMapper.updateById(identityInfo);
    }

    @Override
    public void updateByIdInBatch(List<IdentityInfo> identityInfos) {
        if (CollectionUtils.isEmpty(identityInfos)) {
            return;
        }
        for (IdentityInfo identityInfo: identityInfos) {
            this.updateById(identityInfo);
        }
    }

    @Override
    public IdentityInfo findById(Integer id) {
        return identityInfoMapper.selectById(id);
    }

    @Override
    public IdentityInfo findOne(IdentityInfo identityInfo) {
        QueryWrapper<IdentityInfo> wrapper = new QueryWrapper<>(identityInfo);
        return identityInfoMapper.selectOne(wrapper);
    }

    @Override
    public List<IdentityInfo> findList(IdentityInfo identityInfo) {
        QueryWrapper<IdentityInfo> wrapper = new QueryWrapper<>(identityInfo);
        return identityInfoMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<IdentityInfo> findPage(PageWrap<IdentityInfo> pageWrap) {
        IPage<IdentityInfo> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<IdentityInfo> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(IdentityInfo::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(IdentityInfo::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(IdentityInfo::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(IdentityInfo::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getType, pageWrap.getModel().getType());
        }
        if (pageWrap.getModel().getMemberId() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getMemberId, pageWrap.getModel().getMemberId());
        }
        if (pageWrap.getModel().getAuthType() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getAuthType, pageWrap.getModel().getAuthType());
        }
        if (pageWrap.getModel().getLinkName() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getLinkName, pageWrap.getModel().getLinkName());
        }
        if (pageWrap.getModel().getTelephone() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getTelephone, pageWrap.getModel().getTelephone());
        }
        if (pageWrap.getModel().getLocation() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getLocation, pageWrap.getModel().getLocation());
        }
        if (pageWrap.getModel().getCompanyName() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getCompanyName, pageWrap.getModel().getCompanyName());
        }
        if (pageWrap.getModel().getLat() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getLat, pageWrap.getModel().getLat());
        }
        if (pageWrap.getModel().getLgt() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getLgt, pageWrap.getModel().getLgt());
        }
        if (pageWrap.getModel().getIdentityFront() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getIdentityFront, pageWrap.getModel().getIdentityFront());
        }
        if (pageWrap.getModel().getIdentityBack() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getIdentityBack, pageWrap.getModel().getIdentityBack());
        }
        if (pageWrap.getModel().getBusinessLicense() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getBusinessLicense, pageWrap.getModel().getBusinessLicense());
        }
        if (pageWrap.getModel().getOtherFile() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getOtherFile, pageWrap.getModel().getOtherFile());
        }
        if (pageWrap.getModel().getTransportFile() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getTransportFile, pageWrap.getModel().getTransportFile());
        }
        if (pageWrap.getModel().getFoodBusinessFile() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getFoodBusinessFile, pageWrap.getModel().getFoodBusinessFile());
        }
        if (pageWrap.getModel().getHealthFile() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getHealthFile, pageWrap.getModel().getHealthFile());
        }
        if (pageWrap.getModel().getAuditStatus() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getAuditStatus, pageWrap.getModel().getAuditStatus());
        }
        if (pageWrap.getModel().getAuditTime() != null) {
            queryWrapper.lambda().ge(IdentityInfo::getAuditTime, Utils.Date.getStart(pageWrap.getModel().getAuditTime()));
            queryWrapper.lambda().le(IdentityInfo::getAuditTime, Utils.Date.getEnd(pageWrap.getModel().getAuditTime()));
        }
        if (pageWrap.getModel().getAuditRemark() != null) {
            queryWrapper.lambda().eq(IdentityInfo::getAuditRemark, pageWrap.getModel().getAuditRemark());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(identityInfoMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(IdentityInfo identityInfo) {
        QueryWrapper<IdentityInfo> wrapper = new QueryWrapper<>(identityInfo);
        return identityInfoMapper.selectCount(wrapper);
    }
}

 server/src/main/java/com/doumee/service/business/impl/MemberRevenueServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,157 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.MemberRevenueMapper;
import com.doumee.dao.business.model.MemberRevenue;
import com.doumee.service.business.MemberRevenueService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * ä¼šå‘˜æ”¶æ”¯è®°å½•Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class MemberRevenueServiceImpl implements MemberRevenueService {

    @Autowired
    private MemberRevenueMapper memberRevenueMapper;

    @Override
    public Integer create(MemberRevenue memberRevenue) {
        memberRevenueMapper.insert(memberRevenue);
        return memberRevenue.getId();
    }

    @Override
    public void deleteById(Integer id) {
        memberRevenueMapper.deleteById(id);
    }

    @Override
    public void delete(MemberRevenue memberRevenue) {
        UpdateWrapper<MemberRevenue> deleteWrapper = new UpdateWrapper<>(memberRevenue);
        memberRevenueMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        memberRevenueMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(MemberRevenue memberRevenue) {
        memberRevenueMapper.updateById(memberRevenue);
    }

    @Override
    public void updateByIdInBatch(List<MemberRevenue> memberRevenues) {
        if (CollectionUtils.isEmpty(memberRevenues)) {
            return;
        }
        for (MemberRevenue memberRevenue: memberRevenues) {
            this.updateById(memberRevenue);
        }
    }

    @Override
    public MemberRevenue findById(Integer id) {
        return memberRevenueMapper.selectById(id);
    }

    @Override
    public MemberRevenue findOne(MemberRevenue memberRevenue) {
        QueryWrapper<MemberRevenue> wrapper = new QueryWrapper<>(memberRevenue);
        return memberRevenueMapper.selectOne(wrapper);
    }

    @Override
    public List<MemberRevenue> findList(MemberRevenue memberRevenue) {
        QueryWrapper<MemberRevenue> wrapper = new QueryWrapper<>(memberRevenue);
        return memberRevenueMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<MemberRevenue> findPage(PageWrap<MemberRevenue> pageWrap) {
        IPage<MemberRevenue> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<MemberRevenue> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(MemberRevenue::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(MemberRevenue::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(MemberRevenue::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(MemberRevenue::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getMemberId() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getMemberId, pageWrap.getModel().getMemberId());
        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getType, pageWrap.getModel().getType());
        }
        if (pageWrap.getModel().getOptType() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getOptType, pageWrap.getModel().getOptType());
        }
        if (pageWrap.getModel().getAmount() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getAmount, pageWrap.getModel().getAmount());
        }
        if (pageWrap.getModel().getBeforeAmount() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getBeforeAmount, pageWrap.getModel().getBeforeAmount());
        }
        if (pageWrap.getModel().getAfterAmount() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getAfterAmount, pageWrap.getModel().getAfterAmount());
        }
        if (pageWrap.getModel().getObjId() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getObjId, pageWrap.getModel().getObjId());
        }
        if (pageWrap.getModel().getObjType() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getObjType, pageWrap.getModel().getObjType());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(MemberRevenue::getStatus, pageWrap.getModel().getStatus());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(memberRevenueMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(MemberRevenue memberRevenue) {
        QueryWrapper<MemberRevenue> wrapper = new QueryWrapper<>(memberRevenue);
        return memberRevenueMapper.selectCount(wrapper);
    }
}

 server/src/main/java/com/doumee/service/business/impl/MemberServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,200 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.MemberMapper;
import com.doumee.dao.business.model.Member;
import com.doumee.service.business.MemberService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * ä¼šå‘˜ä¿¡æ¯è¡¨Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class MemberServiceImpl implements MemberService {

    @Autowired
    private MemberMapper memberMapper;

    @Override
    public Integer create(Member member) {
        memberMapper.insert(member);
        return member.getId();
    }

    @Override
    public void deleteById(Integer id) {
        memberMapper.deleteById(id);
    }

    @Override
    public void delete(Member member) {
        UpdateWrapper<Member> deleteWrapper = new UpdateWrapper<>(member);
        memberMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        memberMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(Member member) {
        memberMapper.updateById(member);
    }

    @Override
    public void updateByIdInBatch(List<Member> members) {
        if (CollectionUtils.isEmpty(members)) {
            return;
        }
        for (Member member: members) {
            this.updateById(member);
        }
    }

    @Override
    public Member findById(Integer id) {
        return memberMapper.selectById(id);
    }

    @Override
    public Member findOne(Member member) {
        QueryWrapper<Member> wrapper = new QueryWrapper<>(member);
        return memberMapper.selectOne(wrapper);
    }

    @Override
    public List<Member> findList(Member member) {
        QueryWrapper<Member> wrapper = new QueryWrapper<>(member);
        return memberMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<Member> findPage(PageWrap<Member> pageWrap) {
        IPage<Member> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<Member> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(Member::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(Member::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(Member::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(Member::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(Member::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(Member::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(Member::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(Member::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(Member::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getCoverImage() != null) {
            queryWrapper.lambda().eq(Member::getCoverImage, pageWrap.getModel().getCoverImage());
        }
        if (pageWrap.getModel().getOpenid() != null) {
            queryWrapper.lambda().eq(Member::getOpenid, pageWrap.getModel().getOpenid());
        }
        if (pageWrap.getModel().getNickName() != null) {
            queryWrapper.lambda().eq(Member::getNickName, pageWrap.getModel().getNickName());
        }
        if (pageWrap.getModel().getTelephone() != null) {
            queryWrapper.lambda().eq(Member::getTelephone, pageWrap.getModel().getTelephone());
        }
        if (pageWrap.getModel().getName() != null) {
            queryWrapper.lambda().eq(Member::getName, pageWrap.getModel().getName());
        }
        if (pageWrap.getModel().getWorkerIdentity() != null) {
            queryWrapper.lambda().eq(Member::getWorkerIdentity, pageWrap.getModel().getWorkerIdentity());
        }
        if (pageWrap.getModel().getDriverIdentity() != null) {
            queryWrapper.lambda().eq(Member::getDriverIdentity, pageWrap.getModel().getDriverIdentity());
        }
        if (pageWrap.getModel().getChefIdentity() != null) {
            queryWrapper.lambda().eq(Member::getChefIdentity, pageWrap.getModel().getChefIdentity());
        }
        if (pageWrap.getModel().getAmount() != null) {
            queryWrapper.lambda().eq(Member::getAmount, pageWrap.getModel().getAmount());
        }
        if (pageWrap.getModel().getTotalAmount() != null) {
            queryWrapper.lambda().eq(Member::getTotalAmount, pageWrap.getModel().getTotalAmount());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(Member::getStatus, pageWrap.getModel().getStatus());
        }
        if (pageWrap.getModel().getLoginTime() != null) {
            queryWrapper.lambda().ge(Member::getLoginTime, Utils.Date.getStart(pageWrap.getModel().getLoginTime()));
            queryWrapper.lambda().le(Member::getLoginTime, Utils.Date.getEnd(pageWrap.getModel().getLoginTime()));
        }
        if (pageWrap.getModel().getLoginTimes() != null) {
            queryWrapper.lambda().eq(Member::getLoginTimes, pageWrap.getModel().getLoginTimes());
        }
        if (pageWrap.getModel().getReciveNum() != null) {
            queryWrapper.lambda().eq(Member::getReciveNum, pageWrap.getModel().getReciveNum());
        }
        if (pageWrap.getModel().getPublishNum() != null) {
            queryWrapper.lambda().eq(Member::getPublishNum, pageWrap.getModel().getPublishNum());
        }
        if (pageWrap.getModel().getScore() != null) {
            queryWrapper.lambda().eq(Member::getScore, pageWrap.getModel().getScore());
        }
        if (pageWrap.getModel().getLocaltion() != null) {
            queryWrapper.lambda().eq(Member::getLocaltion, pageWrap.getModel().getLocaltion());
        }
        if (pageWrap.getModel().getLat() != null) {
            queryWrapper.lambda().eq(Member::getLat, pageWrap.getModel().getLat());
        }
        if (pageWrap.getModel().getLgt() != null) {
            queryWrapper.lambda().eq(Member::getLgt, pageWrap.getModel().getLgt());
        }
        if (pageWrap.getModel().getProvince() != null) {
            queryWrapper.lambda().eq(Member::getProvince, pageWrap.getModel().getProvince());
        }
        if (pageWrap.getModel().getCity() != null) {
            queryWrapper.lambda().eq(Member::getCity, pageWrap.getModel().getCity());
        }
        if (pageWrap.getModel().getArea() != null) {
            queryWrapper.lambda().eq(Member::getArea, pageWrap.getModel().getArea());
        }
        if (pageWrap.getModel().getAutoReciveStatus() != null) {
            queryWrapper.lambda().eq(Member::getAutoReciveStatus, pageWrap.getModel().getAutoReciveStatus());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(memberMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(Member member) {
        QueryWrapper<Member> wrapper = new QueryWrapper<>(member);
        return memberMapper.selectCount(wrapper);
    }
}

 server/src/main/java/com/doumee/service/business/impl/OrderLogServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,154 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.OrderLogMapper;
import com.doumee.dao.business.model.OrderLog;
import com.doumee.service.business.OrderLogService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * è®¢å•æ“ä½œæ—¥å¿—Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class OrderLogServiceImpl implements OrderLogService {

    @Autowired
    private OrderLogMapper orderLogMapper;

    @Override
    public Integer create(OrderLog orderLog) {
        orderLogMapper.insert(orderLog);
        return orderLog.getId();
    }

    @Override
    public void deleteById(Integer id) {
        orderLogMapper.deleteById(id);
    }

    @Override
    public void delete(OrderLog orderLog) {
        UpdateWrapper<OrderLog> deleteWrapper = new UpdateWrapper<>(orderLog);
        orderLogMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        orderLogMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(OrderLog orderLog) {
        orderLogMapper.updateById(orderLog);
    }

    @Override
    public void updateByIdInBatch(List<OrderLog> orderLogs) {
        if (CollectionUtils.isEmpty(orderLogs)) {
            return;
        }
        for (OrderLog orderLog: orderLogs) {
            this.updateById(orderLog);
        }
    }

    @Override
    public OrderLog findById(Integer id) {
        return orderLogMapper.selectById(id);
    }

    @Override
    public OrderLog findOne(OrderLog orderLog) {
        QueryWrapper<OrderLog> wrapper = new QueryWrapper<>(orderLog);
        return orderLogMapper.selectOne(wrapper);
    }

    @Override
    public List<OrderLog> findList(OrderLog orderLog) {
        QueryWrapper<OrderLog> wrapper = new QueryWrapper<>(orderLog);
        return orderLogMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<OrderLog> findPage(PageWrap<OrderLog> pageWrap) {
        IPage<OrderLog> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<OrderLog> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(OrderLog::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(OrderLog::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(OrderLog::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(OrderLog::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(OrderLog::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(OrderLog::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(OrderLog::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(OrderLog::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(OrderLog::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getOrderId() != null) {
            queryWrapper.lambda().eq(OrderLog::getOrderId, pageWrap.getModel().getOrderId());
        }
        if (pageWrap.getModel().getTitle() != null) {
            queryWrapper.lambda().eq(OrderLog::getTitle, pageWrap.getModel().getTitle());
        }
        if (pageWrap.getModel().getLogInfo() != null) {
            queryWrapper.lambda().eq(OrderLog::getLogInfo, pageWrap.getModel().getLogInfo());
        }
        if (pageWrap.getModel().getObjType() != null) {
            queryWrapper.lambda().eq(OrderLog::getObjType, pageWrap.getModel().getObjType());
        }
        if (pageWrap.getModel().getMemberId() != null) {
            queryWrapper.lambda().eq(OrderLog::getMemberId, pageWrap.getModel().getMemberId());
        }
        if (pageWrap.getModel().getBeforeInfo() != null) {
            queryWrapper.lambda().eq(OrderLog::getBeforeInfo, pageWrap.getModel().getBeforeInfo());
        }
        if (pageWrap.getModel().getAfterInfo() != null) {
            queryWrapper.lambda().eq(OrderLog::getAfterInfo, pageWrap.getModel().getAfterInfo());
        }
        if (pageWrap.getModel().getOrderStatus() != null) {
            queryWrapper.lambda().eq(OrderLog::getOrderStatus, pageWrap.getModel().getOrderStatus());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(orderLogMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(OrderLog orderLog) {
        QueryWrapper<OrderLog> wrapper = new QueryWrapper<>(orderLog);
        return orderLogMapper.selectCount(wrapper);
    }
}

 server/src/main/java/com/doumee/service/business/impl/OrdersServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,275 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.OrdersMapper;
import com.doumee.dao.business.model.Orders;
import com.doumee.service.business.OrdersService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * è®¢å•ä¿¡æ¯è®°å½•Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class OrdersServiceImpl implements OrdersService {

    @Autowired
    private OrdersMapper ordersMapper;

    @Override
    public Integer create(Orders orders) {
        ordersMapper.insert(orders);
        return orders.getId();
    }

    @Override
    public void deleteById(Integer id) {
        ordersMapper.deleteById(id);
    }

    @Override
    public void delete(Orders orders) {
        UpdateWrapper<Orders> deleteWrapper = new UpdateWrapper<>(orders);
        ordersMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        ordersMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(Orders orders) {
        ordersMapper.updateById(orders);
    }

    @Override
    public void updateByIdInBatch(List<Orders> orderss) {
        if (CollectionUtils.isEmpty(orderss)) {
            return;
        }
        for (Orders orders: orderss) {
            this.updateById(orders);
        }
    }

    @Override
    public Orders findById(Integer id) {
        return ordersMapper.selectById(id);
    }

    @Override
    public Orders findOne(Orders orders) {
        QueryWrapper<Orders> wrapper = new QueryWrapper<>(orders);
        return ordersMapper.selectOne(wrapper);
    }

    @Override
    public List<Orders> findList(Orders orders) {
        QueryWrapper<Orders> wrapper = new QueryWrapper<>(orders);
        return ordersMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<Orders> findPage(PageWrap<Orders> pageWrap) {
        IPage<Orders> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<Orders> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(Orders::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(Orders::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(Orders::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(Orders::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(Orders::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(Orders::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(Orders::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(Orders::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(Orders::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getReleaseMemberId() != null) {
            queryWrapper.lambda().eq(Orders::getReleaseMemberId, pageWrap.getModel().getReleaseMemberId());
        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.lambda().eq(Orders::getType, pageWrap.getModel().getType());
        }
        if (pageWrap.getModel().getStartDate() != null) {
            queryWrapper.lambda().ge(Orders::getStartDate, Utils.Date.getStart(pageWrap.getModel().getStartDate()));
            queryWrapper.lambda().le(Orders::getStartDate, Utils.Date.getEnd(pageWrap.getModel().getStartDate()));
        }
        if (pageWrap.getModel().getEndDate() != null) {
            queryWrapper.lambda().ge(Orders::getEndDate, Utils.Date.getStart(pageWrap.getModel().getEndDate()));
            queryWrapper.lambda().le(Orders::getEndDate, Utils.Date.getEnd(pageWrap.getModel().getEndDate()));
        }
        if (pageWrap.getModel().getLocation() != null) {
            queryWrapper.lambda().eq(Orders::getLocation, pageWrap.getModel().getLocation());
        }
        if (pageWrap.getModel().getLocationRemark() != null) {
            queryWrapper.lambda().eq(Orders::getLocationRemark, pageWrap.getModel().getLocationRemark());
        }
        if (pageWrap.getModel().getLat() != null) {
            queryWrapper.lambda().eq(Orders::getLat, pageWrap.getModel().getLat());
        }
        if (pageWrap.getModel().getProvince() != null) {
            queryWrapper.lambda().eq(Orders::getProvince, pageWrap.getModel().getProvince());
        }
        if (pageWrap.getModel().getCity() != null) {
            queryWrapper.lambda().eq(Orders::getCity, pageWrap.getModel().getCity());
        }
        if (pageWrap.getModel().getArea() != null) {
            queryWrapper.lambda().eq(Orders::getArea, pageWrap.getModel().getArea());
        }
        if (pageWrap.getModel().getLgt() != null) {
            queryWrapper.lambda().eq(Orders::getLgt, pageWrap.getModel().getLgt());
        }
        if (pageWrap.getModel().getCategoryId() != null) {
            queryWrapper.lambda().eq(Orders::getCategoryId, pageWrap.getModel().getCategoryId());
        }
        if (pageWrap.getModel().getWorkType() != null) {
            queryWrapper.lambda().eq(Orders::getWorkType, pageWrap.getModel().getWorkType());
        }
        if (pageWrap.getModel().getPriceNum1() != null) {
            queryWrapper.lambda().eq(Orders::getPriceNum1, pageWrap.getModel().getPriceNum1());
        }
        if (pageWrap.getModel().getPriceNum2() != null) {
            queryWrapper.lambda().eq(Orders::getPriceNum2, pageWrap.getModel().getPriceNum2());
        }
        if (pageWrap.getModel().getSupplement() != null) {
            queryWrapper.lambda().eq(Orders::getSupplement, pageWrap.getModel().getSupplement());
        }
        if (pageWrap.getModel().getPrice() != null) {
            queryWrapper.lambda().eq(Orders::getPrice, pageWrap.getModel().getPrice());
        }
        if (pageWrap.getModel().getEstimatedAccount() != null) {
            queryWrapper.lambda().eq(Orders::getEstimatedAccount, pageWrap.getModel().getEstimatedAccount());
        }
        if (pageWrap.getModel().getPayAccount() != null) {
            queryWrapper.lambda().eq(Orders::getPayAccount, pageWrap.getModel().getPayAccount());
        }
        if (pageWrap.getModel().getReviceAccount() != null) {
            queryWrapper.lambda().eq(Orders::getReviceAccount, pageWrap.getModel().getReviceAccount());
        }
        if (pageWrap.getModel().getPriceRemark() != null) {
            queryWrapper.lambda().eq(Orders::getPriceRemark, pageWrap.getModel().getPriceRemark());
        }
        if (pageWrap.getModel().getCarType() != null) {
            queryWrapper.lambda().eq(Orders::getCarType, pageWrap.getModel().getCarType());
        }
        if (pageWrap.getModel().getTransportTypeId() != null) {
            queryWrapper.lambda().eq(Orders::getTransportTypeId, pageWrap.getModel().getTransportTypeId());
        }
        if (pageWrap.getModel().getTransportNum() != null) {
            queryWrapper.lambda().eq(Orders::getTransportNum, pageWrap.getModel().getTransportNum());
        }
        if (pageWrap.getModel().getTransportUnit() != null) {
            queryWrapper.lambda().eq(Orders::getTransportUnit, pageWrap.getModel().getTransportUnit());
        }
        if (pageWrap.getModel().getLocationEnd() != null) {
            queryWrapper.lambda().eq(Orders::getLocationEnd, pageWrap.getModel().getLocationEnd());
        }
        if (pageWrap.getModel().getLatEnd() != null) {
            queryWrapper.lambda().eq(Orders::getLatEnd, pageWrap.getModel().getLatEnd());
        }
        if (pageWrap.getModel().getLgtEnd() != null) {
            queryWrapper.lambda().eq(Orders::getLgtEnd, pageWrap.getModel().getLgtEnd());
        }
        if (pageWrap.getModel().getWayInfo() != null) {
            queryWrapper.lambda().eq(Orders::getWayInfo, pageWrap.getModel().getWayInfo());
        }
        if (pageWrap.getModel().getCode() != null) {
            queryWrapper.lambda().eq(Orders::getCode, pageWrap.getModel().getCode());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(Orders::getStatus, pageWrap.getModel().getStatus());
        }
        if (pageWrap.getModel().getAcceptTime() != null) {
            queryWrapper.lambda().ge(Orders::getAcceptTime, Utils.Date.getStart(pageWrap.getModel().getAcceptTime()));
            queryWrapper.lambda().le(Orders::getAcceptTime, Utils.Date.getEnd(pageWrap.getModel().getAcceptTime()));
        }
        if (pageWrap.getModel().getAcceptMemberId() != null) {
            queryWrapper.lambda().eq(Orders::getAcceptMemberId, pageWrap.getModel().getAcceptMemberId());
        }
        if (pageWrap.getModel().getAcceptType() != null) {
            queryWrapper.lambda().eq(Orders::getAcceptType, pageWrap.getModel().getAcceptType());
        }
        if (pageWrap.getModel().getWorkStartTime() != null) {
            queryWrapper.lambda().ge(Orders::getWorkStartTime, Utils.Date.getStart(pageWrap.getModel().getWorkStartTime()));
            queryWrapper.lambda().le(Orders::getWorkStartTime, Utils.Date.getEnd(pageWrap.getModel().getWorkStartTime()));
        }
        if (pageWrap.getModel().getFinishTime() != null) {
            queryWrapper.lambda().ge(Orders::getFinishTime, Utils.Date.getStart(pageWrap.getModel().getFinishTime()));
            queryWrapper.lambda().le(Orders::getFinishTime, Utils.Date.getEnd(pageWrap.getModel().getFinishTime()));
        }
        if (pageWrap.getModel().getPlatformRata() != null) {
            queryWrapper.lambda().eq(Orders::getPlatformRata, pageWrap.getModel().getPlatformRata());
        }
        if (pageWrap.getModel().getWxExternalNo() != null) {
            queryWrapper.lambda().eq(Orders::getWxExternalNo, pageWrap.getModel().getWxExternalNo());
        }
        if (pageWrap.getModel().getCommentStatus() != null) {
            queryWrapper.lambda().eq(Orders::getCommentStatus, pageWrap.getModel().getCommentStatus());
        }
        if (pageWrap.getModel().getCommentInfo() != null) {
            queryWrapper.lambda().eq(Orders::getCommentInfo, pageWrap.getModel().getCommentInfo());
        }
        if (pageWrap.getModel().getCommentLevel() != null) {
            queryWrapper.lambda().eq(Orders::getCommentLevel, pageWrap.getModel().getCommentLevel());
        }
        if (pageWrap.getModel().getCommentTime() != null) {
            queryWrapper.lambda().ge(Orders::getCommentTime, Utils.Date.getStart(pageWrap.getModel().getCommentTime()));
            queryWrapper.lambda().le(Orders::getCommentTime, Utils.Date.getEnd(pageWrap.getModel().getCommentTime()));
        }
        if (pageWrap.getModel().getCommentType() != null) {
            queryWrapper.lambda().eq(Orders::getCommentType, pageWrap.getModel().getCommentType());
        }
        if (pageWrap.getModel().getCancelTime() != null) {
            queryWrapper.lambda().ge(Orders::getCancelTime, Utils.Date.getStart(pageWrap.getModel().getCancelTime()));
            queryWrapper.lambda().le(Orders::getCancelTime, Utils.Date.getEnd(pageWrap.getModel().getCancelTime()));
        }
        if (pageWrap.getModel().getIsUpdate() != null) {
            queryWrapper.lambda().eq(Orders::getIsUpdate, pageWrap.getModel().getIsUpdate());
        }
        if (pageWrap.getModel().getBlackRecive() != null) {
            queryWrapper.lambda().eq(Orders::getBlackRecive, pageWrap.getModel().getBlackRecive());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(ordersMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(Orders orders) {
        QueryWrapper<Orders> wrapper = new QueryWrapper<>(orders);
        return ordersMapper.selectCount(wrapper);
    }
}

 server/src/main/java/com/doumee/service/business/impl/ReceiveWeightServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,148 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.ReceiveWeightMapper;
import com.doumee.dao.business.model.ReceiveWeight;
import com.doumee.service.business.ReceiveWeightService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * æŽ¥å•æƒé‡é…ç½®è¡¨Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class ReceiveWeightServiceImpl implements ReceiveWeightService {

    @Autowired
    private ReceiveWeightMapper receiveWeightMapper;

    @Override
    public Integer create(ReceiveWeight receiveWeight) {
        receiveWeightMapper.insert(receiveWeight);
        return receiveWeight.getId();
    }

    @Override
    public void deleteById(Integer id) {
        receiveWeightMapper.deleteById(id);
    }

    @Override
    public void delete(ReceiveWeight receiveWeight) {
        UpdateWrapper<ReceiveWeight> deleteWrapper = new UpdateWrapper<>(receiveWeight);
        receiveWeightMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        receiveWeightMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(ReceiveWeight receiveWeight) {
        receiveWeightMapper.updateById(receiveWeight);
    }

    @Override
    public void updateByIdInBatch(List<ReceiveWeight> receiveWeights) {
        if (CollectionUtils.isEmpty(receiveWeights)) {
            return;
        }
        for (ReceiveWeight receiveWeight: receiveWeights) {
            this.updateById(receiveWeight);
        }
    }

    @Override
    public ReceiveWeight findById(Integer id) {
        return receiveWeightMapper.selectById(id);
    }

    @Override
    public ReceiveWeight findOne(ReceiveWeight receiveWeight) {
        QueryWrapper<ReceiveWeight> wrapper = new QueryWrapper<>(receiveWeight);
        return receiveWeightMapper.selectOne(wrapper);
    }

    @Override
    public List<ReceiveWeight> findList(ReceiveWeight receiveWeight) {
        QueryWrapper<ReceiveWeight> wrapper = new QueryWrapper<>(receiveWeight);
        return receiveWeightMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<ReceiveWeight> findPage(PageWrap<ReceiveWeight> pageWrap) {
        IPage<ReceiveWeight> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<ReceiveWeight> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getStatus, pageWrap.getModel().getStatus());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(ReceiveWeight::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(ReceiveWeight::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(ReceiveWeight::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(ReceiveWeight::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getReceiveMax() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getReceiveMax, pageWrap.getModel().getReceiveMax());
        }
        if (pageWrap.getModel().getReceiveMin() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getReceiveMin, pageWrap.getModel().getReceiveMin());
        }
        if (pageWrap.getModel().getLevel() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getLevel, pageWrap.getModel().getLevel());
        }
        if (pageWrap.getModel().getDelayTime() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getDelayTime, pageWrap.getModel().getDelayTime());
        }
        if (pageWrap.getModel().getSortnum() != null) {
            queryWrapper.lambda().eq(ReceiveWeight::getSortnum, pageWrap.getModel().getSortnum());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(receiveWeightMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(ReceiveWeight receiveWeight) {
        QueryWrapper<ReceiveWeight> wrapper = new QueryWrapper<>(receiveWeight);
        return receiveWeightMapper.selectCount(wrapper);
    }
}

 server/src/main/java/com/doumee/service/business/impl/WithdrawalOrdersServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,149 @@
package com.doumee.service.business.impl;

import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.WithdrawalOrdersMapper;
import com.doumee.dao.business.model.WithdrawalOrders;
import com.doumee.service.business.WithdrawalOrdersService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * æçŽ°ç”³è¯·è®°å½•Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2025/07/09 12:00
 */
@Service
public class WithdrawalOrdersServiceImpl implements WithdrawalOrdersService {

    @Autowired
    private WithdrawalOrdersMapper withdrawalOrdersMapper;

    @Override
    public Integer create(WithdrawalOrders withdrawalOrders) {
        withdrawalOrdersMapper.insert(withdrawalOrders);
        return withdrawalOrders.getId();
    }

    @Override
    public void deleteById(Integer id) {
        withdrawalOrdersMapper.deleteById(id);
    }

    @Override
    public void delete(WithdrawalOrders withdrawalOrders) {
        UpdateWrapper<WithdrawalOrders> deleteWrapper = new UpdateWrapper<>(withdrawalOrders);
        withdrawalOrdersMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        withdrawalOrdersMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(WithdrawalOrders withdrawalOrders) {
        withdrawalOrdersMapper.updateById(withdrawalOrders);
    }

    @Override
    public void updateByIdInBatch(List<WithdrawalOrders> withdrawalOrderss) {
        if (CollectionUtils.isEmpty(withdrawalOrderss)) {
            return;
        }
        for (WithdrawalOrders withdrawalOrders: withdrawalOrderss) {
            this.updateById(withdrawalOrders);
        }
    }

    @Override
    public WithdrawalOrders findById(Integer id) {
        return withdrawalOrdersMapper.selectById(id);
    }

    @Override
    public WithdrawalOrders findOne(WithdrawalOrders withdrawalOrders) {
        QueryWrapper<WithdrawalOrders> wrapper = new QueryWrapper<>(withdrawalOrders);
        return withdrawalOrdersMapper.selectOne(wrapper);
    }

    @Override
    public List<WithdrawalOrders> findList(WithdrawalOrders withdrawalOrders) {
        QueryWrapper<WithdrawalOrders> wrapper = new QueryWrapper<>(withdrawalOrders);
        return withdrawalOrdersMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<WithdrawalOrders> findPage(PageWrap<WithdrawalOrders> pageWrap) {
        IPage<WithdrawalOrders> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<WithdrawalOrders> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDeleted() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getDeleted, pageWrap.getModel().getDeleted());
        }
        if (pageWrap.getModel().getCreateUser() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getCreateUser, pageWrap.getModel().getCreateUser());
        }
        if (pageWrap.getModel().getCreateTime() != null) {
            queryWrapper.lambda().ge(WithdrawalOrders::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
            queryWrapper.lambda().le(WithdrawalOrders::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
        }
        if (pageWrap.getModel().getUpdateUser() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getUpdateUser, pageWrap.getModel().getUpdateUser());
        }
        if (pageWrap.getModel().getUpdateTime() != null) {
            queryWrapper.lambda().ge(WithdrawalOrders::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
            queryWrapper.lambda().le(WithdrawalOrders::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getMemberId() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getMemberId, pageWrap.getModel().getMemberId());
        }
        if (pageWrap.getModel().getAmount() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getAmount, pageWrap.getModel().getAmount());
        }
        if (pageWrap.getModel().getWxExternalNo() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getWxExternalNo, pageWrap.getModel().getWxExternalNo());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getStatus, pageWrap.getModel().getStatus());
        }
        if (pageWrap.getModel().getDoneTime() != null) {
            queryWrapper.lambda().ge(WithdrawalOrders::getDoneTime, Utils.Date.getStart(pageWrap.getModel().getDoneTime()));
            queryWrapper.lambda().le(WithdrawalOrders::getDoneTime, Utils.Date.getEnd(pageWrap.getModel().getDoneTime()));
        }
        if (pageWrap.getModel().getDoneInfo() != null) {
            queryWrapper.lambda().eq(WithdrawalOrders::getDoneInfo, pageWrap.getModel().getDoneInfo());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(withdrawalOrdersMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(WithdrawalOrders withdrawalOrders) {
        QueryWrapper<WithdrawalOrders> wrapper = new QueryWrapper<>(withdrawalOrders);
        return withdrawalOrdersMapper.selectCount(wrapper);
    }
}