p5ebil4zc
/
sky-take-out
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: p5ebil4zc:main
Branches Tags
p5ebil4zc:zhy_branch
p5ebil4zc:hk_branch
p5ebil4zc:main
p5ebil4zc:dev
p5ebil4zc:ls_branch
p5ebil4zc:lh_branch
..
compare: p5ebil4zc:ls_branch
Branches Tags
p5ebil4zc:zhy_branch
p5ebil4zc:hk_branch
p5ebil4zc:main
p5ebil4zc:dev
p5ebil4zc:ls_branch
p5ebil4zc:lh_branch

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

47 changed files with 1792 additions and 3931 deletions
Show Stats

6
.idea/compiler.xml
Unescape View File

@ -17,9 +17,9 @@
</component> </component>
<component name="JavacSettings"> <component name="JavacSettings">
<option name="ADDITIONAL_OPTIONS_OVERRIDE"> <option name="ADDITIONAL_OPTIONS_OVERRIDE">
<module name="sky-common" options="-parameters" /> <module name="sky-common" options="" />
<module name="sky-pojo" options="-parameters" /> <module name="sky-pojo" options="" />
<module name="sky-server" options="-parameters" /> <module name="sky-server" options="" />
</option> </option>
</component> </component>
</project> </project>

5
.idea/jarRepositories.xml
Unescape View File

@ -1,11 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project version="4"> <project version="4">
<component name="RemoteRepositoriesConfiguration"> <component name="RemoteRepositoriesConfiguration">
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Central Repository" />
<option name="url" value="http://maven.aliyun.com/nexus/content/groups/public/" />
</remote-repository>
<remote-repository> <remote-repository>
<option name="id" value="central" /> <option name="id" value="central" />
<option name="name" value="Maven Central repository" /> <option name="name" value="Maven Central repository" />

2
.idea/misc.xml
Unescape View File

@ -14,7 +14,7 @@
</set> </set>
</option> </option>
</component> </component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="17" project-jdk-type="JavaSDK"> <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" /> <output url="file://$PROJECT_DIR$/out" />
</component> </component>
</project> </project>

8
.idea/modules.xml
Unescape View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/sky-take-out.iml" filepath="$PROJECT_DIR$/sky-take-out.iml" />
</modules>
</component>
</project>

112
sky-server/src/main/java/com/sky/controller/admin/DishController.java
Unescape View File

@ -1,7 +1,10 @@
package com.sky.controller.admin; package com.sky.controller.admin;
import com.sky.constant.StatusConstant;
import com.sky.dto.DishDTO;
import com.sky.dto.DishPageQueryDTO;
import com.sky.entity.Dish; import com.sky.entity.Dish;
import com.sky.result.PageResult;
import com.sky.result.Result; import com.sky.result.Result;
import com.sky.service.DishService; import com.sky.service.DishService;
import com.sky.vo.DishVO; import com.sky.vo.DishVO;
@ -10,48 +13,97 @@ import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List; import java.util.List;
import java.util.Set;
@RestController("userDishController") /*
@RequestMapping("/user/dish") * 菜品管理
* */
@RestController
@RequestMapping("/admin/dish")
@Api(tags = "菜品相关接口")
@Slf4j @Slf4j
@Api(tags = "C端-菜品浏览接口")
public class DishController { public class DishController {
@Autowired @Autowired
private DishService dishService; private DishService dishService;
@Autowired @Autowired
private RedisTemplate redisTemplate; private RedisTemplate redisTemplate;
@PostMapping
@ApiOperation("新增菜品")
public Result save(@RequestBody DishDTO dishDTO){
log.info("新增菜品：{}",dishDTO);
dishService.saveWithFlavor(dishDTO);
/** //清理缓存数据
* 根据分类id查询菜品 String key = "dish_" + dishDTO.getCategoryId();
* redisTemplate.delete(key);
* @param categoryId return Result.success();
* @return }
*/
@GetMapping("/list") @GetMapping("/page")
@ApiOperation("根据分类id查询菜品") @ApiOperation("菜品分页查询")
public Result<List<DishVO>> list(Long categoryId) { public Result<PageResult> page(DishPageQueryDTO dishPageQueryDTO){
log.info("菜品分页查询：{}",dishPageQueryDTO);
//构造redis中的key，规则： dish_key分类id PageResult pageResult = dishService.pageQuery(dishPageQueryDTO);
String key = "dish_" + categoryId; return Result.success(pageResult);
//查询redis中是否存在菜品数据 }
List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(key);
if(list != null && list.size() >0){ @DeleteMapping
//如果存在，直接返回，无须查询数据库 @ApiOperation("批量删除菜品")
return Result.success(list); public Result delete(@RequestParam List<Long> ids){
log.info("菜品批量删除：{}",ids);
dishService.deleteBatch(ids);
//将所有菜品缓存数据清理掉，所有以dish_开头的key
cleanCache("dish_*");
return Result.success();
}
@GetMapping("/{id}")
@ApiOperation("根据菜品id获取信息")
public Result<DishVO> getById(@PathVariable Long id){
log.info("根据id获取菜品：{}",id);
DishVO dishVO = dishService.getById(id);
return Result.success(dishVO);
}
@PutMapping
@ApiOperation("修改菜品")
public Result update(@RequestBody DishDTO dishDTO){
log.info("修改菜品：{}",dishDTO);
dishService.updateWithFlavor(dishDTO);
//将所有菜品缓存数据清理掉，所有以dish_开头的key
cleanCache("dish_*");
return Result.success();
} }
//如果不存在，查询数据库，将查询到的数据放入redis中
Dish dish = new Dish();
dish.setCategoryId(categoryId);
dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品
list = dishService.listWithFlavor(dish); @ApiOperation("起售停售菜品")
redisTemplate.opsForValue().set(key,list); @PostMapping("/status/{status}")
public Result StartOrStop(@PathVariable Integer status,Integer id){
log.info("起售停售菜品:{}",status == 1 ? "起售" : "停售");
dishService.startOrStop(status,id);
//将所有菜品缓存数据清理掉，所有以dish_开头的key
cleanCache("dish_*");
return Result.success();
}
@GetMapping("/list")
@ApiOperation("根据分类id查询菜品")
public Result<List<Dish>> getByCategoryId(Long categoryId){
log.info("根据分类id查询菜品：{}",categoryId);
List<Dish> list = dishService.getByCategoryId(categoryId);
return Result.success(list); return Result.success(list);
} }
/*
* 清理缓存数据
* */
private void cleanCache(String pattern){
Set keys = redisTemplate.keys(pattern);
redisTemplate.delete(keys);
}
} }

55
sky-server/src/main/java/com/sky/controller/admin/SetmealController.java
Unescape View File

@ -1,55 +0,0 @@
package com.sky.controller.admin;
import com.sky.constant.StatusConstant;
import com.sky.entity.Setmeal;
import com.sky.result.Result;
import com.sky.service.SetmealService;
import com.sky.vo.DishItemVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController("userSetmealController") // 定义一个REST控制器，并指定其bean名称为"userSetmealController"
@RequestMapping("/user/setmeal") // 设置请求路径前缀为"/user/setmeal"
@Api(tags = "C端-套餐浏览接口") // 使用Swagger注解标记该控制器的API文档标签
public class SetmealController {
@Autowired // 自动注入SetmealService实例
private SetmealService setmealService;
/**
* 根据分类id查询套餐列表
*
* @param categoryId 分类ID
* @return 包含查询结果的Result对象
*/
@GetMapping("/list") // 映射HTTP GET请求到该方法
@ApiOperation("根据分类id查询套餐") // 使用Swagger注解描述该操作的功能
@Cacheable(cacheNames = "setmealCache", key = "#categoryId") // 启用缓存，缓存名为"setmealCache"，键为方法参数categoryId的值
public Result<List<Setmeal>> list(Long categoryId) {
Setmeal setmeal = new Setmeal(); // 创建一个新的Setmeal对象
setmeal.setCategoryId(categoryId); // 设置Setmeal对象的分类ID
setmeal.setStatus(StatusConstant.ENABLE); // 设置Setmeal对象的状态为启用状态
List<Setmeal> list = setmealService.list(setmeal); // 调用服务层方法获取符合条件的套餐列表
return Result.success(list); // 返回包含查询结果的成功响应
}
/**
* 根据套餐id查询包含的菜品列表
*
* @param id 套餐ID
* @return 包含查询结果的Result对象
*/
@GetMapping("/dish/{id}") // 映射HTTP GET请求到该方法，URL中包含动态参数id
@ApiOperation("根据套餐id查询包含的菜品列表") // 使用Swagger注解描述该操作的功能
public Result<List<DishItemVO>> dishList(@PathVariable("id") Long id) { // 从URL路径中提取id参数
List<DishItemVO> list = setmealService.getDishItemById(id); // 调用服务层方法获取指定套餐包含的菜品列表
return Result.success(list); // 返回包含查询结果的成功响应
}
}

65
sky-server/src/main/java/com/sky/controller/admin/ShopController.java
Unescape View File

@ -1,65 +0,0 @@
package com.sky.controller.admin;
import com.sky.result.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
/**
* 该控制器用于管理店铺的相关接口，包括设置店铺的营业状态和获取店铺的营业状态。
*/
@RestController("adminShopController")
@RequestMapping("/admin/shop")
@Api(tags = "店铺相关接口") // 使用 Swagger 注解，标记该类为店铺相关的接口，便于文档生成
@Slf4j // 使用 Lombok 的日志功能，自动生成日志对象
public class ShopController {
// 定义用于存储店铺状态的 Redis 键
public static final String KEY = "SHOP_STATUS";
// 自动注入 RedisTemplate，用于与 Redis 数据库进行交互
@Autowired
private RedisTemplate redisTemplate;
/**
* 设置店铺的营业状态（例如：营业中或打烊中）。
* 根据传入的状态值（1 或 0），更新 Redis 中的店铺状态。
*
* @param status 店铺状态（1 表示营业中，0 表示打烊中）
* @return 返回操作结果
*/
@PutMapping("/{status}") // 使用 PUT 请求方法来更新店铺状态
@ApiOperation("设置店铺的营业状态") // 使用 Swagger 注解，描述该接口的功能
public Result setStatus(@PathVariable Integer status){
// 打印日志，记录当前设置的状态
log.info("设置店铺的营业状态：{}", status == 1 ? "营业中" : "打烊中");
// 将店铺状态存储到 Redis 中，使用 `opsForValue().set` 方法设置键值对
redisTemplate.opsForValue().set(KEY, status);
// 返回成功的操作结果
return Result.success();
}
/**
* 获取当前店铺的营业状态（例如：营业中或打烊中）。
* 从 Redis 中获取店铺状态，并返回。
*
* @return 返回店铺当前状态（1 或 0）
*/
@ApiOperation("获取店铺营业状态") // 使用 Swagger 注解，描述该接口的功能
@GetMapping("/status") // 使用 GET 请求方法获取店铺状态
public Result<Integer> getStatus(){
// 从 Redis 中获取店铺的状态值
Integer status = (Integer) redisTemplate.opsForValue().get(KEY);
// 打印日志，记录当前获取到的状态
log.info("获取店铺营业状态：{}", status == 1 ? "营业中" : "打烊中");
// 返回店铺状态的查询结果，包装在 Result 中
return Result.success(status);
}
}

37
sky-server/src/main/java/com/sky/controller/user/ShopController.java
Unescape View File

@ -1,61 +1,32 @@
package com.sky.controller.user; package com.sky.controller.user;
import com.sky.result.Result; import com.sky.result.Result;
// 引入自定义的Result类，用于统一API响应格式
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
// 引入Swagger注解，用于生成API文档
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
// 引入Swagger注解，用于标注API操作
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
// 引入Slf4j注解，用于生成日志记录器
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
// 引入Spring注解，用于自动注入依赖
import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.RedisTemplate;
// 引入Spring的RedisTemplate，用于操作Redis
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
// 引入Spring的注解，处理HTTP请求
/**
* ShopController类是一个处理与店铺相关接口的控制器，主要用于获取店铺的营业状态。
* 它提供了一个API接口，能够从Redis中获取店铺的营业状态（例如：是否营业中）。
*/
@RestController("userShopController") @RestController("userShopController")
// 注明这是一个Spring的RESTful控制器，指定其bean的名称
@RequestMapping("/user/shop") @RequestMapping("/user/shop")
// 设置根路径映射为 "/user/shop"，所有的请求路径都会以此为前缀
@Api(tags = "店铺相关接口") @Api(tags = "店铺相关接口")
// 使用Swagger注解，定义该控制器的API文档分类为“店铺相关接口”
@Slf4j @Slf4j
// 启用Slf4j日志功能，自动生成日志对象
public class ShopController { public class ShopController {
public static final String KEY = "SHOP_STATUS"; public static final String KEY = "SHOP_STATUS";
// 定义Redis中存储店铺营业状态的key，"SHOP_STATUS"
@Autowired @Autowired
// 自动注入RedisTemplate实例，便于操作Redis
private RedisTemplate redisTemplate; private RedisTemplate redisTemplate;
/** /*
* 获取店铺的营业状态。 * 获取店铺营业状态
* 该方法从Redis中获取店铺状态（例如：是否营业中），并将状态返回给调用者。 * */
* 如果状态为1，则表示“营业中”；否则表示“打烊中”。
*
* @return 返回店铺的营业状态，包装在统一的Result对象中。
*/
@ApiOperation("获取店铺营业状态") @ApiOperation("获取店铺营业状态")
// Swagger注解，描述该方法的功能
@GetMapping("/status") @GetMapping("/status")
// 映射HTTP GET请求，路径为 "/user/shop/status"
public Result<Integer> getStatus(){ public Result<Integer> getStatus(){
// 从Redis中获取存储的店铺状态，值为1时表示营业中，否则表示打烊中
Integer status = (Integer) redisTemplate.opsForValue().get(KEY); Integer status = (Integer) redisTemplate.opsForValue().get(KEY);
// 记录日志，输出当前店铺的营业状态
log.info("获取店铺营业状态：{}",status == 1 ? "营业中" : "打烊中"); log.info("获取店铺营业状态：{}",status == 1 ? "营业中" : "打烊中");
// 返回一个包含状态的成功响应结果
return Result.success(status); return Result.success(status);
} }
} }

95
sky-server/src/main/java/com/sky/controller/user/ShoppingCartController.java
Unescape View File

@ -1,95 +0,0 @@
package com.sky.controller.user;
import com.sky.dto.ShoppingCartDTO; // 导入购物车数据传输对象
import com.sky.entity.ShoppingCart; // 导入购物车实体
import com.sky.result.Result; // 导入统一结果封装类
import com.sky.service.ShoppingCartService; // 导入购物车服务类
import io.swagger.annotations.Api; // 导入 Swagger 注解，用于生成 API 文档
import io.swagger.annotations.ApiOperation; // 导入 Swagger 注解，用于描述接口功能
import lombok.extern.slf4j.Slf4j; // 导入 Lombok 的日志功能
import org.springframework.beans.factory.annotation.Autowired; // 导入 Spring 的自动注入注解
import org.springframework.web.bind.annotation.*; // 导入 Spring Web 注解，用于处理请求
import java.util.List; // 导入 List 集合类
/**
* 购物车相关控制器类，提供用户端（C端）购物车的增、查、删等操作。
*/
@RestController // 将该类标记为一个 RESTful 控制器
@RequestMapping("/user/shoppingCart") // 设置基础请求路径为 "/user/shoppingCart"
@Slf4j // 使用 Lombok 提供的 @Slf4j 注解，自动生成日志记录器
@Api(tags = "C端购物车相关接口") // Swagger 文档注解，标记该类为“C端购物车相关接口”
public class ShoppingCartController {
// 自动注入 ShoppingCartService，用于执行购物车的业务逻辑
@Autowired
private ShoppingCartService shoppingCartService;
/**
* 添加商品到购物车
*
* @param shoppingCartDTO 购物车商品信息传输对象
* @return Result 返回操作结果
*/
@PostMapping("/add") // 设置请求路径为 "/add"，并且使用 POST 方法
@ApiOperation("添加购物车") // Swagger 注解，用于生成 API 文档并描述该接口的功能
public Result add(@RequestBody ShoppingCartDTO shoppingCartDTO) {
// 打印日志，记录添加购物车时的商品信息
log.info("添加购物车，商品信息为：{}", shoppingCartDTO);
// 调用服务层的方法，将商品添加到购物车
shoppingCartService.addShoppingCart(shoppingCartDTO);
// 返回操作成功的结果
return Result.success();
}
/**
* 查看购物车中的所有商品
*
* @return Result<List<ShoppingCart>> 返回购物车商品列表
*/
@GetMapping("/list") // 设置请求路径为 "/list"，并且使用 GET 方法
@ApiOperation("查看购物车") // Swagger 注解，描述该接口的功能
public Result<List<ShoppingCart>> list() {
// 调用服务层方法，获取当前用户购物车中的商品列表
List<ShoppingCart> list = shoppingCartService.showShoppingCart();
// 返回购物车商品列表
return Result.success(list);
}
/**
* 清空购物车中的所有商品
*
* @return Result 返回操作结果
*/
@DeleteMapping("/clean") // 设置请求路径为 "/clean"，并且使用 DELETE 方法
@ApiOperation("清空购物车") // Swagger 注解，描述该接口的功能
public Result clean() {
// 调用服务层方法，清空购物车
shoppingCartService.cleanShoppingCart();
// 返回操作成功的结果
return Result.success();
}
/**
* 从购物车中删除一个商品
*
* @param shoppingCartDTO 购物车商品信息传输对象，包含要删除的商品信息
* @return Result 返回操作结果
*/
@PostMapping("sub") // 设置请求路径为 "/sub"，并且使用 POST 方法
@ApiOperation("删除购物车中一个商品") // Swagger 注解，描述该接口的功能
public Result sub(@RequestBody ShoppingCartDTO shoppingCartDTO) {
// 打印日志，记录删除购物车中的商品信息
log.info("删除购物车中的商品：{}", shoppingCartDTO);
// 调用服务层方法，从购物车中删除指定的商品
shoppingCartService.subShoppingCart(shoppingCartDTO);
// 返回操作成功的结果
return Result.success();
}
}

57
sky-server/src/main/java/com/sky/mapper/AddressBookMapper.java
Unescape View File

@ -1,61 +1,4 @@
package com.sky.mapper; package com.sky.mapper;
import com.sky.entity.AddressBook; // 导入 AddressBook 实体类
import org.apache.ibatis.annotations.*; // 导入 MyBatis 注解
import java.util.List; // 导入 List 集合类
@Mapper // 标识这是一个 MyBatis 的 Mapper 接口，MyBatis 会自动扫描并生成对应的实现
public interface AddressBookMapper { public interface AddressBookMapper {
/**
* 根据条件查询地址簿信息
*
* @param addressBook 包含查询条件的 AddressBook 对象
* @return 返回满足条件的地址簿信息列表
*/
List<AddressBook> list(AddressBook addressBook);
/**
* 新增一条地址信息
*
* @param addressBook 包含新增地址信息的 AddressBook 对象
*/
@Insert("insert into address_book" +
" (user_id, consignee, phone, sex, province_code, province_name, city_code, city_name, district_code," +
" district_name, detail, label, is_default)" +
" values (#{userId}, #{consignee}, #{phone}, #{sex}, #{provinceCode}, #{provinceName}, #{cityCode}, #{cityName}," +
" #{districtCode}, #{districtName}, #{detail}, #{label}, #{isDefault})")
void insert(AddressBook addressBook);
/**
* 根据地址id查询地址信息
*
* @param id 地址id
* @return 返回对应的 AddressBook 对象，如果未找到返回 null
*/
@Select("select * from address_book where id = #{id}")
AddressBook getById(Long id);
/**
* 根据id修改地址信息
*
* @param addressBook 包含更新后的地址信息的 AddressBook 对象
*/
void update(AddressBook addressBook);
/**
* 根据用户id修改是否为默认地址
*
* @param addressBook 包含用户id和是否默认地址的 AddressBook 对象
*/
@Update("update address_book set is_default = #{isDefault} where user_id = #{userId}")
void updateIsDefaultByUserId(AddressBook addressBook);
/**
* 根据地址id删除地址信息
*
* @param id 地址id
*/
@Delete("delete from address_book where id = #{id}")
void deleteById(Long id);
} }

34
sky-server/src/main/java/com/sky/mapper/DishFlavorMapper.java
Unescape View File

@ -1,34 +0,0 @@
package com.sky.mapper;
import com.sky.entity.DishFlavor;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface DishFlavorMapper {
/*
* 批量插入口味数据
* */
void insertBatch(List<DishFlavor> flavors);
/*
* 根据菜品id删除对应口味
* */
@Delete("delete from dish_flavor where dish_id = #{dishId}")
void deleteByDishId(Long dishId);
/*
* 根据菜品id集合批量删除关联的口味数据
* */
void deleteByDishIds(List<Long> dishIds);
/*
* 根据菜品id返回口味数据
* */
@Select("select * from dish_flavor where dish_id = #{dishId}")
List<DishFlavor> getByDishId(Long dishId);
}

72
sky-server/src/main/java/com/sky/mapper/SetmealMapper.java
Unescape View File

@ -1,76 +1,4 @@
package com.sky.mapper; package com.sky.mapper;
import com.github.pagehelper.Page;
import com.sky.annotation.AutoFill;
import com.sky.dto.SetmealPageQueryDTO;
import com.sky.entity.Setmeal;
import com.sky.enumeration.OperationType;
import com.sky.vo.DishItemVO;
import com.sky.vo.SetmealVO;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
import java.util.Map;
@Mapper
public interface SetmealMapper { public interface SetmealMapper {
/**
* 根据分类id查询套餐的数量
* @param id
* @return
*/
@Select("select count(id) from setmeal where category_id = #{categoryId}")
Integer countByCategoryId(Long id);
/*
* 新增套餐
* */
@AutoFill(OperationType.INSERT)
void insert(Setmeal setmeal);
Page<SetmealVO> pageQuery(SetmealPageQueryDTO setmealPageQueryDTO);
/*
* 根据套餐id获取套餐数据
* */
@Select("select * from setmeal where id = #{id}")
Setmeal getById(Long Id);
void deleteBatch(List<Long> ids);
@AutoFill(OperationType.UPDATE)
void updateWithDish(Setmeal setmeal);
@Update("update setmeal set status = #{status} where id = #{id}")
void startOrStop(Setmeal setmeal);
/**
* 动态条件查询套餐
* @param setmeal
* @return
*/
List<Setmeal> list(Setmeal setmeal);
/**
* 根据套餐id查询菜品选项
* @param setmealId
* @return
*/
@Select("select sd.name, sd.copies, d.image, d.description " +
"from setmeal_dish sd left join dish d on sd.dish_id = d.id " +
"where sd.setmeal_id = #{setmealId}")
List<DishItemVO> getDishItemBySetmealId(Long setmealId);
/**
* 根据条件统计套餐数量
* @param map
* @return
*/
Integer countByMap(Map map);
} }

89
sky-server/src/main/java/com/sky/mapper/ShoppingCartMapper.java
Unescape View File

@ -1,93 +1,4 @@
package com.sky.mapper; package com.sky.mapper;
import com.sky.entity.ShoppingCart;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Update;
import java.util.List;
@Mapper // 标识该接口为 MyBatis 的 Mapper，MyBatis 会自动生成代理类并进行依赖注入
public interface ShoppingCartMapper { public interface ShoppingCartMapper {
/**
* 根据动态条件查询购物车数据
*
* @param shoppingCart 包含查询条件的购物车对象，支持动态查询
* @return 返回符合条件的购物车列表
*
* 该方法可以根据传入的 `shoppingCart` 对象中设置的字段进行动态查询，例如：
* - 如果传入的购物车对象中设置了 `userId`，则查询该用户的购物车数据。
* - 如果设置了 `dishId`，则查询特定菜品的购物车数据等。
*
* 具体的查询条件在 MyBatis 的 XML 映射文件中根据 `shoppingCart` 对象的属性动态拼接。
*/
List<ShoppingCart> list(ShoppingCart shoppingCart);
/**
* 根据购物车项 ID 修改该项的食品数量
*
* @param shoppingCart 包含要更新数量和对应 ID 的购物车对象
*
* 该方法通过 `shoppingCart` 对象的 `id` 和 `number` 字段来更新数据库中的数据。
* - `id` 是购物车项的唯一标识符。
* - `number` 是购物车项中食品的数量。
*
* SQL 语句会通过 MyBatis 注解的方式执行，更新对应购物车项的 `number` 字段。
*/
@Update("update shopping_cart set number = #{number} where id = #{id}")
void updateNumberById(ShoppingCart shoppingCart);
/**
* 插入一条新的购物车数据
*
* @param shoppingCart 包含要插入的购物车项数据
*
* 该方法用于插入一条新的购物车记录。传入的 `shoppingCart` 对象会被映射到数据库的字段中。
* - 该操作会将 `name`, `image`, `userId`, `dishId`, `setmealId`, `dishFlavor`, `amount`, `createTime` 等字段的值插入到数据库。
*
* SQL 语句通过 MyBatis 注解的方式执行。
*/
@Insert("insert into shopping_cart(name, image, user_id, dish_id, setmeal_id, dish_flavor, amount, create_time) " +
"values (#{name},#{image},#{userId},#{dishId},#{setmealId},#{dishFlavor},#{amount},#{createTime})")
void insert(ShoppingCart shoppingCart);
/**
* 根据用户 ID 删除该用户的所有购物车数据
*
* @param userId 要删除购物车数据的用户 ID
*
* 该方法通过传入的 `userId` 删除该用户的所有购物车记录。
* - 当用户不再需要这些购物车项时，可以调用此方法来清除所有与该用户相关的购物车数据。
*
* SQL 语句通过 MyBatis 注解的方式执行，条件是 `user_id` 字段等于传入的 `userId`。
*/
@Delete("delete from shopping_cart where user_id = #{userId}")
void deleteByUserId(Long userId);
/**
* 根据购物车项的 ID 删除指定的购物车数据
*
* @param id 购物车项的唯一标识符
*
* 该方法通过传入的购物车项 `id` 删除对应的购物车记录。
* - `id` 是购物车项在数据库中的唯一标识符。
*
* SQL 语句通过 MyBatis 注解的方式执行，条件是 `id` 字段等于传入的 `id`。
*/
@Delete("delete from shopping_cart where id = #{id}")
void deleteById(Long id);
/**
* 批量插入购物车数据
*
* @param shoppingCartList 包含多个购物车项数据的列表
*
* 该方法允许一次性插入多条购物车记录。`shoppingCartList` 是包含多个 `ShoppingCart` 对象的列表。
* - 每个 `ShoppingCart` 对象代表一条购物车数据，将其对应的字段插入到 `shopping_cart` 表中。
*
* 该方法的实现可能通过 MyBatis 的批量插入功能，提升性能。
*/
void insertBatch(List<ShoppingCart> shoppingCartList);
} }

85
sky-server/src/main/java/com/sky/service/AddressBookService.java
Unescape View File

@ -1,85 +0,0 @@
package com.sky.service;
import com.sky.entity.AddressBook;
import java.util.List;
/**
* AddressBookService 接口定义了地址簿相关的服务操作。
* 该接口提供了增、删、查、改、列出等地址簿操作的抽象方法。
* 地址簿（AddressBook）是一个表示个人或企业联系人信息的实体，
* 可能包含如姓名、电话、地址等字段。
*/
public interface AddressBookService {
/**
* 获取地址簿列表。
* 根据传入的地址簿对象（可包含筛选条件），返回匹配的地址簿列表。
*
* @param addressBook 包含筛选条件的地址簿对象，允许为空，表示不进行任何筛选。
* 如果传入的 `addressBook` 对象不为空，方法会根据该对象的字段（如名称、电话等）进行筛选。
* @return 返回地址簿对象的列表。该列表包含所有符合筛选条件的地址簿记录。
*
* 例如，如果 `addressBook` 中包含名称字段，可以用该字段进行模糊查询，返回与名称匹配的地址簿列表。
*/
List<AddressBook> list(AddressBook addressBook);
/**
* 保存一个新的地址簿。
* 该方法将一个新的地址簿对象保存到数据库中。
*
* @param addressBook 要保存的地址簿对象，包含新的联系人信息。
* 该对象会被映射到数据库中的相应字段，并存储到数据库。
*
* 例如，保存的 `addressBook` 对象可能包含姓名、电话、详细地址等信息，并将这些信息存储到数据库的地址簿表中。
*/
void save(AddressBook addressBook);
/**
* 根据 ID 获取地址簿信息。
* 根据提供的地址簿 ID 从数据库中检索对应的地址簿对象。
*
* @param id 地址簿的唯一标识符（ID），该 ID 用于在数据库中查找相应的地址簿记录。
* @return 返回指定 ID 的地址簿对象。若未找到对应的记录，可能返回 null 或抛出异常（具体实现根据需求决定）。
*
* 该方法一般用于根据唯一标识符（如数据库的主键）查找具体的地址簿对象。
*/
AddressBook getById(Long id);
/**
* 更新地址簿信息。
* 该方法会更新传入的地址簿对象中的数据，并保存更改到数据库。
*
* @param addressBook 要更新的地址簿对象，包含了需要更新的联系人信息。
* 该对象的字段会更新到数据库中对应的记录，通常通过 ID 进行匹配更新。
*
* 例如，如果传入的 `addressBook` 对象的 `id` 对应的记录已经存在，
* 那么该方法会将数据库中对应字段的数据更新为传入的对象中的新值。
*/
void update(AddressBook addressBook);
/**
* 设置地址簿为默认地址。
* 该方法将传入的地址簿对象设置为默认地址，通常是将某个字段标记为 "默认"。
*
* @param addressBook 要设置为默认的地址簿对象。
* 该对象通常包含一个标志位字段（如 `isDefault`），
* 用于指示该地址是否为默认地址。
*
* 例如，设置 `addressBook` 对象的 `isDefault` 字段为 `true`，
* 标记该地址为默认地址，并确保其他地址的 `isDefault` 字段为 `false`。
*/
void setDefault(AddressBook addressBook);
/**
* 根据 ID 删除地址簿信息。
* 该方法根据提供的地址簿 ID 删除对应的地址簿记录。
*
* @param id 要删除的地址簿的 ID，表示要删除的记录的唯一标识符。
*
* 该方法将根据传入的 `id` 删除数据库中对应的地址簿记录，
* 若删除成功，则该记录将不再存在于数据库中。
*
* 例如，通过传入地址簿的 `id`，数据库中与该 `id` 关联的记录将被删除。
*/
void deleteById(Long id);
}

50
sky-server/src/main/java/com/sky/service/DishService.java
Unescape View File

@ -1,50 +0,0 @@
package com.sky.service;
import com.sky.dto.DishDTO;
import com.sky.dto.DishPageQueryDTO;
import com.sky.entity.Dish;
import com.sky.result.PageResult;
import com.sky.vo.DishVO;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.List;
public interface DishService {
/*
* 新增菜品和对应的口味
* */
void saveWithFlavor(DishDTO dishDTO);
/*
* 菜品分页查询
* */
PageResult pageQuery(DishPageQueryDTO dishPageQueryDTO);
void deleteBatch(List<Long> ids);
/*
* 根据菜品id返回菜品和口味数据
* */
DishVO getById(Long id);
/*
* 根据id修改菜品基本信息和对应口味信息
* */
void updateWithFlavor(DishDTO dishDTO);
List<Dish> getByCategoryId(Long categoryId);
/**
* 条件查询菜品和口味
* @param dish
* @return
*/
List<DishVO> listWithFlavor(Dish dish);
void startOrStop(Integer status, Integer id);
}

65
sky-server/src/main/java/com/sky/service/SetmealService.java
Unescape View File

@ -1,65 +0,0 @@
package com.sky.service;
import com.sky.dto.SetmealDTO;
import com.sky.dto.SetmealPageQueryDTO;
import com.sky.result.PageResult;
import com.sky.vo.DishItemVO;
import com.sky.vo.SetmealVO;
import com.sky.entity.Setmeal;
import java.util.List;
public interface SetmealService {
/**
* 保存套餐及其包含的菜品信息
* @param setmealDTO 包含套餐和菜品信息的数据传输对象
*/
public void saveWithDishes(SetmealDTO setmealDTO);
/**
* 分页查询套餐信息
* @param setmealPageQueryDTO 包含分页查询条件的数据传输对象
* @return 分页结果，包括总记录数和当前页数据
*/
PageResult page(SetmealPageQueryDTO setmealPageQueryDTO);
/**
* 删除指定ID列表的套餐
* @param ids 要删除的套餐ID列表
*/
void delete(List<Long> ids);
/**
* 根据ID获取套餐详细信息
* @param id 套餐ID
* @return 包含套餐详细信息的视图对象
*/
SetmealVO getById(Long id);
/**
* 更新套餐及其包含的菜品信息
* @param setmealDTO 包含更新后的套餐和菜品信息的数据传输对象
*/
void updateWithDish(SetmealDTO setmealDTO);
/**
* 启动或停止指定ID的套餐销售状态
* @param status 新的销售状态（1表示启用，0表示停用）
* @param id 套餐ID
*/
void startOrStop(Integer status, Long id);
/**
* 条件查询套餐列表
* @param setmeal 包含查询条件的套餐实体对象
* @return 符合条件的套餐列表
*/
List<Setmeal> list(Setmeal setmeal);
/**
* 根据套餐ID查询其包含的菜品选项
* @param id 套餐ID
* @return 包含菜品选项的视图对象列表
*/
List<DishItemVO> getDishItemById(Long id);
}

46
sky-server/src/main/java/com/sky/service/ShoppingCartService.java
Unescape View File

@ -1,46 +0,0 @@
package com.sky.service;
import com.sky.dto.ShoppingCartDTO;
import com.sky.entity.ShoppingCart;
import java.util.List;
/**
* ShoppingCartService 接口定义了购物车相关的服务操作。
* 该接口提供了购物车的增、删、查看、清空等操作的抽象方法。
* 购物车（ShoppingCart）是用于存储用户选购商品的对象，可以进行管理和操作。
*/
public interface ShoppingCartService {
/**
* 添加商品到购物车。
* 该方法根据传入的购物车数据对象（ShoppingCartDTO），将商品添加到用户的购物车中。
*
* @param shoppingCartDTO 包含购物车商品信息的数据传输对象（DTO），如商品ID、数量等。
* 该对象用于封装用户请求的购物车操作数据。
*/
void addShoppingCart(ShoppingCartDTO shoppingCartDTO);
/**
* 查看当前购物车中的所有商品。
* 该方法返回当前用户购物车中所有商品的列表。
*
* @return 返回一个购物车对象列表，包含当前购物车中所有的商品及其数量等信息。
*/
List<ShoppingCart> showShoppingCart();
/**
* 清空购物车。
* 该方法将删除购物车中的所有商品，将购物车清空。
*/
void cleanShoppingCart();
/**
* 从购物车中减少商品数量。
* 该方法根据传入的购物车数据对象（ShoppingCartDTO），减少指定商品在购物车中的数量。
*
* @param shoppingCartDTO 包含商品信息的数据传输对象（DTO），如商品ID和减少的数量。
* 如果减少后的数量为0或以下，可能会触发从购物车中完全删除该商品。
*/
void subShoppingCart(ShoppingCartDTO shoppingCartDTO);
}

99
sky-server/src/main/java/com/sky/service/impl/AddressBookServiceImpl.java
Unescape View File

@ -1,99 +0,0 @@
package com.sky.service.impl;
import com.sky.context.BaseContext;
import com.sky.entity.AddressBook;
import com.sky.mapper.AddressBookMapper;
import com.sky.service.AddressBookService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service // 标识该类为一个服务层组件，会被 Spring 扫描并管理
@Slf4j // 使用 Lombok 提供的日志功能，自动生成日志记录器
public class AddressBookServiceImpl implements AddressBookService {
@Autowired // 自动注入 AddressBookMapper，进行数据库操作
private AddressBookMapper addressBookMapper;
/**
* 条件查询地址簿数据
*
* @param addressBook 包含查询条件的 AddressBook 对象
* @return 返回符合条件的 AddressBook 列表
*/
public List<AddressBook> list(AddressBook addressBook) {
// 调用 mapper 层的 list 方法，执行查询操作
return addressBookMapper.list(addressBook);
}
/**
* 新增地址到地址簿
*
* @param addressBook 包含地址数据的 AddressBook 对象
*/
public void save(AddressBook addressBook) {
// 设置当前用户的 ID，假设 BaseContext.getCurrentId() 返回当前用户的 ID
addressBook.setUserId(BaseContext.getCurrentId());
// 默认将新增的地址设置为非默认地址
addressBook.setIsDefault(0);
// 调用 mapper 层的 insert 方法执行插入操作
addressBookMapper.insert(addressBook);
}
/**
* 根据地址 ID 查询地址
*
* @param id 地址的唯一标识符
* @return 返回匹配的 AddressBook 对象
*/
public AddressBook getById(Long id) {
// 调用 mapper 层的 getById 方法查询地址
AddressBook addressBook = addressBookMapper.getById(id);
return addressBook; // 返回查询结果
}
/**
* 根据地址 ID 修改地址信息
*
* @param addressBook 包含更新数据的 AddressBook 对象
*/
public void update(AddressBook addressBook) {
// 调用 mapper 层的 update 方法更新地址数据
addressBookMapper.update(addressBook);
}
/**
* 设置指定地址为默认地址
*
* 该方法使用事务管理，确保操作的原子性：
* 1. 将当前用户所有地址的默认状态更新为非默认。
* 2. 将指定地址设置为默认地址。
*
* @param addressBook 包含要设置为默认地址的 AddressBook 对象
*/
@Transactional // 标识该方法为事务性方法，多个操作要么全部成功，要么全部失败
public void setDefault(AddressBook addressBook) {
// 1. 将当前用户的所有地址修改为非默认地址
addressBook.setIsDefault(0); // 将 isDefault 设置为 0（非默认）
addressBook.setUserId(BaseContext.getCurrentId()); // 设置用户 ID
// 调用 mapper 层的 updateIsDefaultByUserId 方法更新所有地址的默认状态
addressBookMapper.updateIsDefaultByUserId(addressBook);
// 2. 将当前地址改为默认地址
addressBook.setIsDefault(1); // 将 isDefault 设置为 1（默认）
// 调用 mapper 层的 update 方法更新指定地址的默认状态
addressBookMapper.update(addressBook);
}
/**
* 根据地址 ID 删除指定地址
*
* @param id 地址的唯一标识符
*/
public void deleteById(Long id) {
// 调用 mapper 层的 deleteById 方法删除指定的地址
addressBookMapper.deleteById(id);
}
}

190
sky-server/src/main/java/com/sky/service/impl/DishServiceImpl.java
Unescape View File

@ -1,190 +0,0 @@
package com.sky.service.impl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.sky.constant.MessageConstant;
import com.sky.constant.StatusConstant;
import com.sky.dto.DishDTO;
import com.sky.dto.DishPageQueryDTO;
import com.sky.entity.Dish;
import com.sky.entity.DishFlavor;
import com.sky.exception.DeletionNotAllowedException;
import com.sky.mapper.DishFlavorMapper;
import com.sky.mapper.DishMapper;
import com.sky.mapper.SetmealDishMapper;
import com.sky.result.PageResult;
import com.sky.service.DishService;
import com.sky.vo.DishVO;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
@Service
@Slf4j
public class DishServiceImpl implements DishService {
@Autowired
private DishMapper dishMapper;
@Autowired
private DishFlavorMapper dishFlavorMapper;
@Autowired
private SetmealDishMapper setmealDishMapper;
/**
* 新增菜品和对应的口味
* @param dishDTO 包含菜品信息和口味信息的数据传输对象
*/
@Transactional
public void saveWithFlavor(DishDTO dishDTO) {
// 创建一个新的Dish对象，并从DishDTO中复制属性
Dish dish = new Dish();
BeanUtils.copyProperties(dishDTO, dish);
// 向菜品表插入1条数据
dishMapper.insert(dish);
// 获取insert语句生成的主键值
Long dishId = dish.getId();
// 向口味表插入n条数据
List<DishFlavor> flavors = dishDTO.getFlavors();
if (flavors != null && flavors.size() > 0) {
flavors.forEach(dishFlavor -> {
dishFlavor.setDishId(dishId); // 设置口味的菜品ID为新插入的菜品ID
});
// 向口味表插入n条数据
dishFlavorMapper.insertBatch(flavors);
}
}
/**
* 分页查询菜品
* @param dishPageQueryDTO 包含分页查询条件的数据传输对象
* @return 分页结果，包括总记录数和当前页的数据列表
*/
@Override
public PageResult pageQuery(DishPageQueryDTO dishPageQueryDTO) {
// 开启分页查询，设置当前页和每页显示的记录数
PageHelper.startPage(dishPageQueryDTO.getPage(), dishPageQueryDTO.getPageSize());
// 根据条件查询菜品数据，返回分页结果
Page<DishVO> page = dishMapper.pageQuery(dishPageQueryDTO);
return new PageResult(page.getTotal(), page.getResult());
}
/**
* 批量删除菜品
* @param ids 要删除的菜品ID列表
*/
@Transactional
public void deleteBatch(List<Long> ids) {
// 判断当前菜品是否能删除 -- 起售状态检查
for (Long id : ids) {
Dish dish = dishMapper.getById(id);
if (dish.getStatus() == StatusConstant.ENABLE) {
throw new DeletionNotAllowedException(MessageConstant.DISH_ON_SALE);
}
}
// 检查菜品是否被套餐关联
List<Long> setmealIds = setmealDishMapper.getSetmealIdsByDishIds(ids);
if (setmealIds != null && setmealIds.size() > 0) {
// 当前菜品被套餐关联，抛出异常
throw new DeletionNotAllowedException(MessageConstant.DISH_BE_RELATED_BY_SETMEAL);
}
// 根据菜品id集合批量删除菜品数据
dishMapper.deleteByIds(ids);
// 根据菜品id集合批量删除关联的口味数据
dishFlavorMapper.deleteByDishIds(ids);
}
/**
* 根据ID查询菜品及其口味信息
* @param id 菜品ID
* @return 包含菜品基本信息和口味信息的视图对象
*/
@Override
public DishVO getById(Long id) {
// 根据id查询菜品数据
Dish dish = dishMapper.getById(id);
// 查询口味数据
List<DishFlavor> dishFlavors = dishFlavorMapper.getByDishId(id);
// 封装到vo对象
DishVO dishVO = new DishVO();
BeanUtils.copyProperties(dish, dishVO);
dishVO.setFlavors(dishFlavors);
return dishVO;
}
/**
* 更新菜品及其口味信息
* @param dishDTO 包含菜品信息和口味信息的数据传输对象
*/
@Override
public void updateWithFlavor(DishDTO dishDTO) {
// 修改菜品表基本信息
Dish dish = new Dish();
BeanUtils.copyProperties(dishDTO, dish);
dishMapper.update(dish);
// 删除再插入口味数据
dishFlavorMapper.deleteByDishId(dishDTO.getId());
List<DishFlavor> flavors = dishDTO.getFlavors();
if (flavors != null && flavors.size() > 0) {
flavors.forEach(dishFlavor -> {
dishFlavor.setDishId(dishDTO.getId()); // 设置口味的菜品ID为更新后的菜品ID
});
// 向口味表插入n条数据
dishFlavorMapper.insertBatch(flavors);
}
}
/**
* 根据分类ID查询启用状态的菜品列表
* @param categoryId 分类ID
* @return 启用状态的菜品列表
*/
@Override
public List<Dish> getByCategoryId(Long categoryId) {
Dish dish = Dish.builder()
.categoryId(categoryId)
.status(StatusConstant.ENABLE)
.build();
return dishMapper.getByCategoryId(dish);
}
/**
* 条件查询菜品和口味信息
* @param dish 包含查询条件的菜品对象
* @return 符合条件的菜品视图对象列表
*/
public List<DishVO> listWithFlavor(Dish dish) {
List<Dish> dishList = dishMapper.getByCategoryId(dish); // 根据分类ID查询菜品列表
List<DishVO> dishVOList = new ArrayList<>(); // 用于存储最终的菜品视图对象列表
for (Dish d : dishList) { // 遍历查询到的菜品列表
DishVO dishVO = new DishVO(); // 创建新的菜品视图对象
BeanUtils.copyProperties(d, dishVO); // 将菜品对象的属性复制到视图对象中
// 根据菜品id查询对应的口味
List<DishFlavor> flavors = dishFlavorMapper.getByDishId(d.getId()); // 查询口味列表
dishVO.setFlavors(flavors); // 设置视图对象的口味列表属性
dishVOList.add(dishVO); // 将视图对象添加到最终列表中
}
return dishVOList; // 返回最终的菜品视图对象列表
}
/**
* 启动或停止菜品销售状态
* @param status 目标状态（启用或停用）
* @param id 菜品ID
*/
@Override
public void startOrStop(Integer status, Integer id) {
dishMapper.startOrStop(status, id); // 更新菜品的销售状态
}
}

162
sky-server/src/main/java/com/sky/service/impl/SetmealServiceImpl.java
Unescape View File

@ -1,162 +0,0 @@
package com.sky.service.impl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.sky.constant.MessageConstant;
import com.sky.constant.StatusConstant;
import com.sky.dto.SetmealDTO;
import com.sky.dto.SetmealPageQueryDTO;
import com.sky.entity.Dish;
import com.sky.entity.Employee;
import com.sky.entity.Setmeal;
import com.sky.entity.SetmealDish;
import com.sky.exception.DeletionNotAllowedException;
import com.sky.mapper.DishMapper;
import com.sky.mapper.SetmealDishMapper;
import com.sky.mapper.SetmealMapper;
import com.sky.result.PageResult;
import com.sky.service.SetmealService;
import com.sky.vo.DishItemVO;
import com.sky.vo.DishVO;
import com.sky.vo.SetmealVO;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class SetmealServiceImpl implements SetmealService {
@Autowired
private SetmealMapper setmealMapper; // 注入套餐Mapper
@Autowired
private DishMapper dishMapper; // 注入菜品Mapper
@Autowired
private SetmealDishMapper setmealDishMapper; // 注入套餐菜品关系Mapper
/*
* 新增套餐
* */
@Override
@Transactional
public void saveWithDishes(SetmealDTO setmealDTO) {
// 创建套餐对象并复制属性
Setmeal setmeal = new Setmeal();
BeanUtils.copyProperties(setmealDTO, setmeal);
// 向套餐表插入一条数据
setmealMapper.insert(setmeal);
// 获取新插入的套餐ID
Long setmealId = setmealDTO.getId();
// 获取套餐中的菜品列表
List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();
// 为每个菜品设置对应的套餐ID
setmealDishes.forEach(setmealDish -> {
setmealDish.setSetmealId(setmealId);
});
// 向套餐菜品关系表插入多条数据
setmealDishMapper.insertBatch(setmealDishes);
}
@Override
public PageResult page(SetmealPageQueryDTO setmealPageQueryDTO) {
// 开启分页查询，设置当前页和每页显示记录数
PageHelper.startPage(setmealPageQueryDTO.getPage(), setmealPageQueryDTO.getPageSize());
// 执行分页查询，获取结果集
Page<SetmealVO> page = setmealMapper.pageQuery(setmealPageQueryDTO);
// 返回分页结果，包含总记录数和当前页数据
return new PageResult(page.getTotal(), page.getResult());
}
@Transactional
public void delete(List<Long> ids) {
// 遍历要删除的套餐ID列表
for (Long id : ids) {
// 根据ID查询套餐信息
Setmeal setmeal = setmealMapper.getById(id);
// 如果套餐正在销售中，则抛出异常，不允许删除
if (setmeal.getStatus() == StatusConstant.ENABLE) {
throw new DeletionNotAllowedException(MessageConstant.SETMEAL_ON_SALE);
}
}
// 批量删除套餐表中的数据
setmealMapper.deleteBatch(ids);
// 批量删除套餐菜品关系表中的数据
setmealDishMapper.deleteBySetmealIds(ids);
}
/*
* 根据id获取套餐数据
* 以及相应的菜品数据
* */
@Override
public SetmealVO getById(Long id) {
// 根据ID查询套餐信息
Setmeal setmeal = setmealMapper.getById(id);
// 创建套餐视图对象并复制属性
SetmealVO setmealVO = new SetmealVO();
BeanUtils.copyProperties(setmeal, setmealVO);
// 根据套餐ID查询关联的菜品列表
List<SetmealDish> setmealDishes = setmealDishMapper.getBySetmealId(id);
// 将菜品列表设置到套餐视图对象中
setmealVO.setSetmealDishes(setmealDishes);
// 返回套餐视图对象
return setmealVO;
}
@Transactional
public void updateWithDish(SetmealDTO setmealDTO) {
// 创建套餐对象并复制属性
Setmeal setmeal = new Setmeal();
BeanUtils.copyProperties(setmealDTO, setmeal);
// 更新套餐表中的数据
setmealMapper.updateWithDish(setmeal);
// 获取套餐ID
Long setmealId = setmealDTO.getId();
// 删除旧的套餐菜品关系数据
setmealDishMapper.deleteBySetmealId(setmealId);
// 获取新的套餐菜品列表
List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();
// 为每个新的菜品设置对应的套餐ID
for (SetmealDish setmealDish : setmealDishes) {
setmealDish.setSetmealId(setmealDTO.getId());
}
// 向套餐菜品关系表插入新的数据
setmealDishMapper.insertBatch(setmealDishes);
}
@Override
public void startOrStop(Integer status, Long id) {
// 构建套餐对象并设置状态和ID
Setmeal setmeal = Setmeal.builder()
.status(status)
.id(id)
.build();
// 更新套餐表中的销售状态
setmealMapper.startOrStop(setmeal);
}
/**
* 条件查询
* @param setmeal 套餐实体对象，用于封装查询条件
* @return 符合条件的套餐列表
*/
public List<Setmeal> list(Setmeal setmeal) {
// 根据条件查询套餐列表
List<Setmeal> list = setmealMapper.list(setmeal);
// 返回查询结果
return list;
}
/**
* 根据id查询菜品选项
* @param id 套餐ID
* @return 菜品选项列表
*/
public List<DishItemVO> getDishItemById(Long id) {
// 根据套餐ID查询菜品选项列表
return setmealMapper.getDishItemBySetmealId(id);
}
}

140
sky-server/src/main/java/com/sky/service/impl/ShoppingCartServiceImpl.java
Unescape View File

@ -1,140 +0,0 @@
package com.sky.service.impl;
import com.fasterxml.jackson.databind.ser.Serializers;
import com.sky.context.BaseContext;
import com.sky.dto.ShoppingCartDTO;
import com.sky.entity.Dish;
import com.sky.entity.Setmeal;
import com.sky.entity.ShoppingCart;
import com.sky.mapper.DishMapper;
import com.sky.mapper.SetmealMapper;
import com.sky.mapper.ShoppingCartMapper;
import com.sky.service.ShoppingCartService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
@Service
@Slf4j
public class ShoppingCartServiceImpl implements ShoppingCartService {
@Autowired
private ShoppingCartMapper shoppingCartMapper;
// 注入购物车数据库操作接口
@Autowired
private DishMapper dishMapper;
// 注入菜品数据库操作接口
@Autowired
private SetmealMapper setmealMapper;
// 注入套餐数据库操作接口
/*
* 添加购物车
* */
@Override
public void addShoppingCart(ShoppingCartDTO shoppingCartDTO) {
// 创建购物车对象，并将DTO数据复制到实体对象中
ShoppingCart shoppingCart = new ShoppingCart();
BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
// 获取当前用户的ID（假设通过BaseContext获取）
Long userId = BaseContext.getCurrentId();
shoppingCart.setUserId(userId);
// 查询当前用户购物车中是否已有此商品
List<ShoppingCart> list = shoppingCartMapper.list(shoppingCart);
// 如果购物车中已经有该商品，数量加1
if (list != null && list.size() > 0) {
ShoppingCart cart = list.get(0);
cart.setNumber(cart.getNumber() + 1); // 更新购物车中商品的数量 + 1
shoppingCartMapper.updateNumberById(cart); // 更新数据库中的购物车数据
} else {
// 如果购物车中没有该商品，插入一条新的购物车记录
Long dishId = shoppingCartDTO.getDishId();
if (dishId != null) {
// 如果添加的是菜品
Dish dish = dishMapper.getById(dishId); // 从数据库查询该菜品的信息
shoppingCart.setName(dish.getName()); // 设置菜品名称
shoppingCart.setImage(dish.getImage()); // 设置菜品图片
shoppingCart.setAmount(dish.getPrice()); // 设置菜品价格
} else {
// 如果添加的是套餐
Long setmealId = shoppingCart.getSetmealId();
Setmeal setmeal = setmealMapper.getById(setmealId); // 从数据库查询该套餐的信息
shoppingCart.setName(setmeal.getName()); // 设置套餐名称
shoppingCart.setImage(setmeal.getImage()); // 设置套餐图片
shoppingCart.setAmount(setmeal.getPrice()); // 设置套餐价格
}
shoppingCart.setNumber(1); // 新增购物车商品，数量为1
shoppingCart.setCreateTime(LocalDateTime.now()); // 设置当前时间为创建时间
shoppingCartMapper.insert(shoppingCart); // 将购物车记录插入数据库
}
}
/*
* 查看购物车
* */
@Override
public List<ShoppingCart> showShoppingCart() {
// 获取当前用户ID
Long userId = BaseContext.getCurrentId();
// 创建一个ShoppingCart对象，只设置了用户ID，用于查询该用户的购物车
ShoppingCart shoppingCart = ShoppingCart.builder()
.userId(userId)
.build();
// 查询该用户的购物车数据并返回
List<ShoppingCart> list = shoppingCartMapper.list(shoppingCart);
return list;
}
/*
* 清空购物车
* */
@Override
public void cleanShoppingCart() {
// 获取当前用户ID
Long userId = BaseContext.getCurrentId();
// 调用删除方法，清空该用户的所有购物车数据
shoppingCartMapper.deleteByUserId(userId);
}
/*
* 减少购物车中商品的数量
* */
@Override
public void subShoppingCart(ShoppingCartDTO shoppingCartDTO) {
// 创建购物车对象，并将DTO数据复制到实体对象中
ShoppingCart shoppingCart = new ShoppingCart();
BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
// 获取当前用户的ID
Long userId = BaseContext.getCurrentId();
shoppingCart.setUserId(userId);
// 查询该用户的购物车数据
List<ShoppingCart> list = shoppingCartMapper.list(shoppingCart);
if (list != null && list.size() > 0) {
shoppingCart = list.get(0);
Integer number = shoppingCart.getNumber();
// 如果商品数量为1，删除这条购物车记录
if (number == 1) {
shoppingCartMapper.deleteById(shoppingCart.getId()); // 删除该商品
} else {
// 如果商品数量大于1，将数量减1并更新数据库
shoppingCart.setNumber(shoppingCart.getNumber() - 1); // 减少商品数量
shoppingCartMapper.updateNumberById(shoppingCart); // 更新购物车数据
}
}
}
}

59
sky-server/src/main/resources/mapper/AddressBookMapper.xml
Unescape View File

@ -1,59 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sky.mapper.AddressBookMapper">
<!-- 查询地址簿列表 -->
<select id="list" parameterType="AddressBook" resultType="com.sky.entity.AddressBook">
<!-- 从 address_book 表中查询数据 -->
select * from address_book
<where>
<!-- 如果传入的 userId 不为 null，则添加查询条件：user_id = #{userId} -->
<if test="userId != null">
and user_id = #{userId}
</if>
<!-- 如果传入的 phone 不为 null，则添加查询条件：phone = #{phone} -->
<if test="phone != null">
and phone = #{phone}
</if>
<!-- 如果传入的 isDefault 不为 null，则添加查询条件：is_default = #{isDefault} -->
<if test="isDefault != null">
and is_default = #{isDefault}
</if>
</where>
</select>
<!-- 更新地址簿中的一条记录 -->
<update id="update" parameterType="addressBook">
<!-- 更新 address_book 表中的数据 -->
update address_book
<set>
<!-- 如果 consignee 不为 null，则更新 consignee 字段 -->
<if test="consignee != null">
consignee = #{consignee},
</if>
<!-- 如果 sex 不为 null，则更新 sex 字段 -->
<if test="sex != null">
sex = #{sex},
</if>
<!-- 如果 phone 不为 null，则更新 phone 字段 -->
<if test="phone != null">
phone = #{phone},
</if>
<!-- 如果 detail 不为 null，则更新 detail 字段 -->
<if test="detail != null">
detail = #{detail},
</if>
<!-- 如果 label 不为 null，则更新 label 字段 -->
<if test="label != null">
label = #{label},
</if>
<!-- 如果 isDefault 不为 null，则更新 is_default 字段 -->
<if test="isDefault != null">
is_default = #{isDefault},
</if>
</set>
<!-- 根据传入的 id 更新指定的记录 -->
where id = #{id}
</update>
</mapper>

30
sky-server/src/main/resources/mapper/DishFlavorMapper.xml
Unescape View File

@ -1,30 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- 定义XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 声明这是一个MyBatis的mapper文件，并指定DTD文件的位置 -->
<mapper namespace="com.sky.mapper.DishFlavorMapper">
<!-- 定义命名空间，通常对应于一个Java接口 -->
<insert id="insertBatch">
<!-- 定义一个插入操作，id为insertBatch -->
insert into dish_flavor (dish_id, name, value) values
<!-- 插入数据的SQL语句，向dish_flavor表中插入数据 -->
<foreach collection="list" item="flavor" separator=",">
<!-- 使用MyBatis的foreach标签遍历传入的列表 -->
(#{flavor.dishId},#{flavor.name},#{flavor.value})
<!-- 对每个元素进行插入操作，使用#{flavor.dishId}等占位符来引用对象的属性 -->
</foreach>
</insert>
<delete id="deleteByDishIds">
<!-- 定义一个删除操作，id为deleteByDishIds -->
delete from dish_flavor where dish_id in
<!-- 删除dish_flavor表中满足条件的记录 -->
<foreach collection="dishIds" open="(" close=")" separator="," item="dishId">
<!-- 使用MyBatis的foreach标签遍历传入的dishIds集合 -->
#{dishId}
<!-- 对每个元素进行删除操作，使用#{dishId}占位符来引用集合中的元素 -->
</foreach>
</delete>
</mapper>

101
sky-server/src/main/resources/mapper/DishMapper.xml
Unescape View File

@ -1,101 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 定义MyBatis的映射文件，namespace指定对应的Java接口 -->
<mapper namespace="com.sky.mapper.DishMapper">
<!-- 插入一条新的菜品记录，并返回生成的主键ID -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
insert into dish (name, category_id, price, image, description, create_time, update_time, create_user, update_user, status)
values
(#{name},#{categoryId},#{price},#{image},#{description},#{createTime},#{updateTime},#{createUser},#{updateUser},#{status})
</insert>
<!-- 根据多个ID删除菜品记录 -->
<delete id="deleteByIds">
delete from dish where id in
<foreach collection="ids" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</delete>
<!-- 分页查询菜品信息，根据条件进行筛选 -->
<select id="pageQuery" resultType="com.sky.vo.DishVO" parameterType="com.sky.dto.DishPageQueryDTO">
select d.*,cg.name categoryName from dish d,category cg
<where>
d.category_id = cg.id
<if test="name !=null">
and d.name like concat('%',#{name},'%')
</if>
<if test="categoryId !=null">
and d.category_id = #{categoryId}
</if>
<if test="status != null">
and d.status = #{status}
</if>
</where>
order by d.create_time desc
</select>
<!-- 根据分类ID获取菜品列表 -->
<select id="getByCategoryId" resultType="com.sky.entity.Dish">
select * from dish
<where>
<if test="name != null">
and name like concat('%',#{name},'%')
</if>
<if test="categoryId != null">
and category_id = #{categoryId}
</if>
<if test="status != null">
and status = #{status}
</if>
</where>
order by create_time desc
</select>
<!-- 更新菜品信息 -->
<update id="update" parameterType="com.sky.entity.Dish">
update dish
<set>
<if test="name != null">
name = #{name},
</if>
<if test="categoryId != null">
category_id = #{categoryId},
</if>
<if test="price != null">
price = #{price},
</if>
<if test="image != null">
image = #{image},
</if>
<if test="description != null">
description = #{description},
</if>
<if test="status != null">
status = #{status},
</if>
<if test="updateTime != null">
update_time = #{updateTime},
</if>
<if test="updateUser != null">
update_user = #{updateUser},
</if>
</set>
where id = #{id}
</update>
<!-- 根据状态和分类ID统计菜品数量 -->
<select id="countByMap" resultType="java.lang.Integer">
select count(id) from dish
<where>
<if test="status != null">
and status = #{status}
</if>
<if test="categoryId != null">
and category_id = #{categoryId}
</if>
</where>
</select>
</mapper>

8
sky-server/src/main/resources/mapper/OrderDetailMapper.xml
Unescape View File

@ -1,18 +1,14 @@
<?xml version="1.0" encoding="UTF-8" ?> <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 定义XML文档的版本和编码 -->
<mapper namespace="com.sky.mapper.OrderDetailMapper"> <mapper namespace="com.sky.mapper.OrderDetailMapper">
<!-- 指定命名空间，通常对应于一个Java接口 -->
<insert id="insertBatch"> <insert id="insertBatch">
<!-- 定义一个插入操作，id为insertBatch -->
insert into order_detail(name, image, order_id, dish_id, setmeal_id, dish_flavor, amount) insert into order_detail(name, image, order_id, dish_id, setmeal_id, dish_flavor, amount)
values values
<!-- 插入数据的SQL语句，向order_detail表中插入数据 -->
<foreach collection="orderDetailList" item="od" separator=","> <foreach collection="orderDetailList" item="od" separator=",">
<!-- 使用MyBatis的foreach标签遍历传入的orderDetailList集合 -->
(#{od.name},#{od.image},#{od.orderId},#{od.dishId},#{od.setmealId},#{od.dishFlavor},#{od.amount}) (#{od.name},#{od.image},#{od.orderId},#{od.dishId},#{od.setmealId},#{od.dishFlavor},#{od.amount})
<!-- 对每个元素进行插入操作，使用#{od.name}等占位符来引用对象的属性 -->
</foreach> </foreach>
</insert> </insert>
</mapper> </mapper>

17
sky-server/src/main/resources/mapper/OrderMapper.xml
Unescape View File

@ -1,10 +1,7 @@
<?xml version="1.0" encoding="UTF-8" ?> <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 定义XML文档的版本和编码 -->
<mapper namespace="com.sky.mapper.OrderMapper"> <mapper namespace="com.sky.mapper.OrderMapper">
<!-- 指定命名空间，通常对应于一个Java接口 -->
<!-- 插入订单记录 -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id"> <insert id="insert" useGeneratedKeys="true" keyProperty="id">
insert into orders(number, status, user_id, address_book_id, order_time, insert into orders(number, status, user_id, address_book_id, order_time,
checkout_time, pay_method, pay_status, amount, remark, checkout_time, pay_method, pay_status, amount, remark,
@ -18,11 +15,9 @@
#{deliveryStatus},#{deliveryTime},#{packAmount},#{tablewareNumber},#{tablewareStatus}) #{deliveryStatus},#{deliveryTime},#{packAmount},#{tablewareNumber},#{tablewareStatus})
</insert> </insert>
<!-- 更新订单记录 -->
<update id="update" parameterType="com.sky.entity.Orders"> <update id="update" parameterType="com.sky.entity.Orders">
update orders update orders
<set> <set>
<!-- 根据条件动态更新字段 -->
<if test="cancelReason != null and cancelReason!='' "> <if test="cancelReason != null and cancelReason!='' ">
cancel_reason=#{cancelReason}, cancel_reason=#{cancelReason},
</if> </if>
@ -50,13 +45,10 @@
</set> </set>
where id = #{id} where id = #{id}
</update> </update>
<!-- 分页查询订单 -->
<select id="pageQuery" resultType="com.sky.entity.Orders"> <select id="pageQuery" resultType="com.sky.entity.Orders">
select * select *
from orders from orders
<where> <where>
<!-- 根据条件动态拼接查询语句 -->
<if test="number != null and number!=''"> <if test="number != null and number!=''">
and number like concat('%',#{number},'%') and number like concat('%',#{number},'%')
</if> </if>
@ -77,13 +69,10 @@
</if> </if>
</where> </where>
</select> </select>
<!-- 计算订单金额总和 -->
<select id="sumByMap" resultType="java.lang.Double"> <select id="sumByMap" resultType="java.lang.Double">
select sum(amount) select sum(amount)
from orders from orders
<where> <where>
<!-- 根据条件动态拼接查询语句 -->
<if test="begin != null"> <if test="begin != null">
and order_time &gt; #{begin} and order_time &gt; #{begin}
</if> </if>
@ -95,13 +84,10 @@
</if> </if>
</where> </where>
</select> </select>
<!-- 统计订单数量 -->
<select id="countByMap" resultType="java.lang.Integer"> <select id="countByMap" resultType="java.lang.Integer">
select count(id) select count(id)
from orders from orders
<where> <where>
<!-- 根据条件动态拼接查询语句 -->
<if test="begin != null"> <if test="begin != null">
and order_time &gt; #{begin} and order_time &gt; #{begin}
</if> </if>
@ -113,15 +99,12 @@
</if> </if>
</where> </where>
</select> </select>
<!-- 获取销售前十的商品 -->
<select id="getSalesTop10" resultType="com.sky.dto.GoodsSalesDTO"> <select id="getSalesTop10" resultType="com.sky.dto.GoodsSalesDTO">
select od.name,sum(od.number) as number select od.name,sum(od.number) as number
from order_detail od,orders o from order_detail od,orders o
where where
od.order_id = o.id od.order_id = o.id
and o.status = 5 and o.status = 5
<!-- 根据条件动态拼接查询语句 -->
<if test="begin != null"> <if test="begin != null">
and o.order_time &gt; #{begin} and o.order_time &gt; #{begin}
</if> </if>

41
sky-server/src/main/resources/mapper/SetmealDishMapper.xml
Unescape View File

@ -1,41 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- 定义XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 声明这是一个MyBatis的映射文件，并指定DTD的位置 -->
<mapper namespace="com.sky.mapper.SetmealDishMapper">
<!-- 定义命名空间，通常对应于一个Java接口 -->
<insert id="insertBatch">
<!-- 定义一个插入操作，id为insertBatch -->
insert into setmeal_dish(setmeal_id, dish_id, name, price, copies)
values
<foreach collection="list" item="setmealDish" separator=",">
<!-- 使用foreach循环遍历传入的list集合，每个元素命名为setmealDish -->
(#{setmealDish.setmealId},#{setmealDish.dishId},#{setmealDish.name},#{setmealDish.price},#{setmealDish.copies})
<!-- 将每个setmealDish对象的属性值插入到数据库中 -->
</foreach>
</insert>
<delete id="deleteBySetmealIds">
<!-- 定义一个删除操作，id为deleteBySetmealIds -->
delete from setmeal_dish
where setmeal_id in
<foreach collection="setmealIds" item="setmealId" open="(" close=")" separator=",">
<!-- 使用foreach循环遍历传入的setmealIds集合，每个元素命名为setmealId -->
#{setmealId}
<!-- 将每个setmealId的值用于SQL语句中的IN条件 -->
</foreach>
</delete>
<select id="getSetmealIdsByDishIds" resultType="java.lang.Long">
<!-- 定义一个查询操作，id为getSetmealIdsByDishIds，返回类型为java.lang.Long -->
select setmeal_id from setmeal_dish
where dish_id in
<foreach collection="dishIds" item="dishId" separator="," open="(" close=")">
<!-- 使用foreach循环遍历传入的dishIds集合，每个元素命名为dishId -->
#{dishId}
<!-- 将每个dishId的值用于SQL语句中的IN条件 -->
</foreach>
</select>
</mapper>

85
sky-server/src/main/resources/mapper/SetmealMapper.xml
Unescape View File

@ -1,85 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 定义MyBatis的映射文件，namespace指定对应的Java接口 -->
<mapper namespace="com.sky.mapper.SetmealMapper">
<!-- 插入一条新的套餐记录 -->
<insert id="insert">
insert into setmeal(category_id, name, price, description, image, create_time, update_time, create_user, update_user,status)
values(#{categoryId},#{name},#{price},#{description},#{image},#{createTime},#{updateTime},#{createUser},#{updateUser},#{status})
</insert>
<!-- 根据多个ID批量删除套餐记录 -->
<delete id="deleteBatch">
delete from setmeal
where id in
<foreach collection="ids" item="id" separator="," open="(" close=")">
#{id}
</foreach>
</delete>
<!-- 分页查询套餐信息，根据条件进行筛选 -->
<select id="pageQuery" resultType="com.sky.vo.SetmealVO">
select s.*,c.name categoryName from setmeal s,category c
<where>
s.category_id = c.id
<if test="name !=null">
and s.name like concat('%',#{name},'%')
</if>
<if test="categoryId !=null">
and s.category_id = #{categoryId}
</if>
<if test="status != null">
and s.status = #{status}
</if>
</where>
order by s.create_time desc
</select>
<!-- 更新套餐信息，包括关联的菜品信息 -->
<update id="updateWithDish">
update setmeal
<set>
<if test="categoryId != null">category_id = #{categoryId},</if>
<if test="name != null">name = #{name},</if>
<if test="price != null">price = #{price},</if>
<if test="status != null">status = #{status},</if>
<if test="description != null">description = #{description},</if>
<if test="image != null">image = #{image},</if>
<if test="updateTime != null">update_time = #{updateTime},</if>
<if test="updateUser != null">update_user = #{updateUser}</if>
</set>
where id = #{id}
</update>
<!-- 根据条件查询套餐列表 -->
<select id="list" parameterType="Setmeal" resultType="com.sky.entity.Setmeal">
select * from setmeal
<where>
<if test="name != null">
and name like concat('%',#{name},'%')
</if>
<if test="categoryId != null">
and category_id = #{categoryId}
</if>
<if test="status != null">
and status = #{status}
</if>
</where>
</select>
<!-- 根据状态和分类ID统计套餐数量 -->
<select id="countByMap" resultType="java.lang.Integer">
select count(id) from setmeal
<where>
<if test="status != null">
and status = #{status}
</if>
<if test="categoryId != null">
and category_id = #{categoryId}
</if>
</where>
</select>
</mapper>

42
sky-server/src/main/resources/mapper/ShoppingCartMapper.xml
Unescape View File

@ -1,42 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sky.mapper.ShoppingCartMapper">
<!-- 批量插入购物车数据 -->
<insert id="insertBatch" parameterType="list">
<!-- 向 shopping_cart 表插入数据 -->
insert into shopping_cart
(name, image, user_id, dish_id, setmeal_id, dish_flavor, amount, create_time)
values
<!-- 使用 foreach 元素遍历传入的 shoppingCartList 列表，将每一项数据作为一条记录插入 -->
<foreach collection="shoppingCartList" item="sc" separator=",">
<!-- 每一条记录的数据字段映射 -->
(#{sc.name},#{sc.image},#{sc.userId},#{sc.dishId},#{sc.setmealId},#{sc.dishFlavor},#{sc.amount},#{sc.createTime})
</foreach>
</insert>
<!-- 查询购物车列表 -->
<select id="list" resultType="com.sky.entity.ShoppingCart">
<!-- 从 shopping_cart 表中查询数据 -->
select * from shopping_cart
<where>
<!-- 如果传入的 userId 不为 null，则添加查询条件：user_id = #{userId} -->
<if test="userId != null">
and user_id = #{userId}
</if>
<!-- 如果传入的 setmealId 不为 null，则添加查询条件：setmeal_id = #{setmealId} -->
<if test="setmealId != null">
and setmeal_id = #{setmealId}
</if>
<!-- 如果传入的 dishId 不为 null，则添加查询条件：dish_id = #{dishId} -->
<if test="dishId != null">
and dish_id = #{dishId}
</if>
<!-- 如果传入的 dishFlavor 不为 null，则添加查询条件：dish_flavor = #{dishFlavor} -->
<if test="dishFlavor != null">
and dish_flavor = #{dishFlavor}
</if>
</where>
</select>
</mapper>

1476
user/mp-weixin/common/vendor.js
View File

File diff suppressed because it is too large Load Diff

81
user/mp-weixin/components/empty/empty.js
Unescape View File

@ -77,39 +77,17 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
var components var components
// `render` 是 Vue.js 组件中的一个渲染函数，负责渲染该组件的视图。
// 它使用了 Vue 实例的上下文来生成虚拟 DOM。
var render = function() { var render = function() {
// `_vm` 是当前 Vue 实例的引用，代表组件本身。
var _vm = this var _vm = this
// `_h` 是 Vue 的 $createElement 方法的别名，用于创建虚拟 DOM 元素。
// 如果 `_vm._self._c` 存在，则 `_c` 是一个引用当前 Vue 实例的 `createElement` 方法。
// 否则它会使用默认的 `createElement` 方法 `_h`。
var _h = _vm.$createElement var _h = _vm.$createElement
// `_c` 是创建虚拟 DOM 的函数，这里使用 `_vm._self._c || _h` 确保它有一个有效的创建函数。
// Vue 在渲染时会使用这个方法来构建组件的 DOM 结构。
var _c = _vm._self._c || _h var _c = _vm._self._c || _h
} }
// `recyclableRender` 是一个布尔值，表示该渲染函数是否可以被重用。
// 在某些情况下，Vue 会优化渲染函数，使其能够被回收和重用，以提高性能。
var recyclableRender = false var recyclableRender = false
// `staticRenderFns` 是一个数组，存储的是静态渲染函数。
// 静态渲染函数不会在每次渲染时被重新计算，而是被缓存起来，以提高性能。
// 在这个代码中，`staticRenderFns` 初始化为空数组，意味着没有静态的渲染函数。
var staticRenderFns = [] var staticRenderFns = []
// `render._withStripped = true` 是一个优化标志，表示在构建生产环境版本时，
// 会去掉渲染函数中的一些开发环境的辅助工具和调试信息，
// 以减小生成的 JavaScript 文件体积，提高性能。
render._withStripped = true render._withStripped = true
/***/ }), /***/ }),
/***/ 197: /***/ 197:
@ -143,63 +121,29 @@ Object.defineProperty(exports, "__esModule", { value: true });exports.default =
// //
// //
// //
// 这是一个 Vue 组件的默认配置对象 var _default =
var _default = { {
// `props` 定义了组件的属性（Props），即外部传递给组件的数据
props: { props: {
// `boxHeight` 属性，类型为 String，默认值为 '100vh'
// 该属性用于设置组件的高度，如果没有传值则默认高度为视口高度
'boxHeight': { 'boxHeight': {
type: String, type: String,
default: '100vh' default: '100vh' },
},
// `textLabel` 属性，类型为 String，默认值为 '暂无数据'
// 该属性用于显示一个文本标签，默认显示为 '暂无数据'
'textLabel': { 'textLabel': {
type: String, type: String,
default: '暂无数据' default: '暂无数据' } },
}
},
// `data` 定义了组件的响应式数据
// 这里没有定义任何数据，因此返回一个空对象
data: function data() { data: function data() {
return {}; return {};
},
// `components` 定义了当前组件所使用的子组件 },
// 目前为空对象，表示没有引入任何子组件
components: {}, components: {},
// `created` 生命周期钩子，在组件实例创建后调用
// 目前为空函数，表示在创建时没有执行任何操作
created: function created() {}, created: function created() {},
// `mounted` 生命周期钩子，在组件挂载到 DOM 后调用
// 目前为空函数，表示在挂载后没有执行任何操作
mounted: function mounted() {}, mounted: function mounted() {},
// `computed` 定义了计算属性，用于根据已有数据计算新的值
// 目前为空对象，表示没有定义任何计算属性
computed: {}, computed: {},
// `methods` 定义了组件中可用的方法
// 目前为空对象，表示没有定义任何方法
methods: {}, methods: {},
// `watch` 定义了观察者，用于监听组件的数据变化
// 目前为空对象，表示没有监听任何数据变化
watch: {}, watch: {},
filters: {} };exports.default = _default;
// `filters` 定义了过滤器，用于处理展示的数据
// 目前为空对象，表示没有定义任何过滤器
filters: {}
};
// 将组件的默认配置导出
exports.default = _default;
/***/ }), /***/ }),
@ -234,21 +178,12 @@ __webpack_require__.r(__webpack_exports__);
}]); }]);
//# sourceMappingURL=../../../.sourcemap/mp-weixin/components/empty/empty.js.map //# sourceMappingURL=../../../.sourcemap/mp-weixin/components/empty/empty.js.map
;// 将组件相关代码推送到 `webpackJsonp` 数组中，这样 Webpack 可以处理模块加载和依赖关系 ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
// 这是一个唯一的模块标识符，用于区分该模块
'components/empty/empty-create-component', 'components/empty/empty-create-component',
{ {
// 定义了 'components/empty/empty-create-component' 模块的行为
'components/empty/empty-create-component':(function(module, exports, __webpack_require__){ 'components/empty/empty-create-component':(function(module, exports, __webpack_require__){
// 使用 Webpack 动态加载依赖，并调用 `createComponent` 方法
// 该方法可能用于创建一个 Vue 组件或类似框架的组件
// 这里依赖模块 '1'，然后调用该模块的 `createComponent` 方法，传入模块 194 的内容
// __webpack_require__('1') 引用的是 Webpack 编译时生成的模块标识符 '1'
// __webpack_require__(194) 引用的是模块 194，可能是组件的具体实现或定义
__webpack_require__('1')['createComponent'](__webpack_require__(194)) __webpack_require__('1')['createComponent'](__webpack_require__(194))
}) })
}, },
// 这是一个数组，指定了该模块的依赖关系。此处该模块的依赖是 'components/empty/empty-create-component'
[['components/empty/empty-create-component']] [['components/empty/empty-create-component']]
]); ]);

89
user/mp-weixin/components/reach-bottom/reach-bottom.js
Unescape View File

@ -23,33 +23,20 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 Vue CLI 插件生成的 componentNormalizer 函数来规范化组件
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
// 传入的第一个参数是组件的脚本部分，它负责组件的逻辑
_reach_bottom_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _reach_bottom_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 传入的第二个参数是组件的模板部分，负责定义组件的结构和布局
_reach_bottom_vue_vue_type_template_id_262745a4___WEBPACK_IMPORTED_MODULE_0__["render"], _reach_bottom_vue_vue_type_template_id_262745a4___WEBPACK_IMPORTED_MODULE_0__["render"],
// 传入的第三个参数是模板的静态渲染函数，主要用于优化性能，渲染静态部分
_reach_bottom_vue_vue_type_template_id_262745a4___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _reach_bottom_vue_vue_type_template_id_262745a4___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 第四个参数是布尔值，通常用来指示是否需要将该组件的代码标记为异步组件，false 表示此组件是同步加载的
false, false,
// 第五个和第六个参数是给该组件传入的特殊标识符，一般为 `name` 和 `inject` 等
null, null,
null, null,
// 第七个参数是组件的作用域和热更新标志，这里为 null 表示没有特殊处理
null, null,
// 第八个参数是布尔值，指示是否需要进行 server-side rendering (SSR) 优化
false, false,
// 第九个参数是组件中依赖的其他子组件，这里通过传入的 `components` 来绑定
_reach_bottom_vue_vue_type_template_id_262745a4___WEBPACK_IMPORTED_MODULE_0__["components"], _reach_bottom_vue_vue_type_template_id_262745a4___WEBPACK_IMPORTED_MODULE_0__["components"],
// 第十个参数是一个渲染函数，在需要手动渲染模板时使用
renderjs renderjs
) )
// 给生成的组件添加文件名信息，方便调试和追踪
component.options.__file = "components/reach-bottom/reach-bottom.vue" component.options.__file = "components/reach-bottom/reach-bottom.vue"
// 默认导出该规范化后的组件对象，使得该组件可以在其他地方被引用
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);
/***/ }), /***/ }),
@ -83,41 +70,20 @@ __webpack_require__.r(__webpack_exports__);
/*! exports provided: render, staticRenderFns, recyclableRender, components */ /*! exports provided: render, staticRenderFns, recyclableRender, components */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
// 使用严格模式，这有助于捕获潜在的错误并确保代码的安全性
"use strict"; "use strict";
// 调用 __webpack_require__.r 来标记当前模块为 ES6 模块
__webpack_require__.r(__webpack_exports__); __webpack_require__.r(__webpack_exports__);
// 使用 __webpack_require__.d 来为模块绑定导出
// 第一个导出：render 函数，它负责定义组件的渲染逻辑
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "render", function() { return render; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "render", function() { return render; });
// 第二个导出：staticRenderFns，它包含静态渲染函数，用于优化静态部分的渲染
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
// 第三个导出：recyclableRender，指示是否启用可回收的渲染，默认值为 false
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
// 第四个导出：components，组件内的子组件列表，用于注册和使用
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
// 组件的子组件列表，暂时没有定义任何子组件
var components var components
// 定义 render 函数，它描述了组件的渲染逻辑
var render = function() { var render = function() {
var _vm = this // 获取当前 Vue 实例 var _vm = this
var _h = _vm.$createElement // 获取 Vue 的 $createElement 方法，用于创建虚拟 DOM 元素 var _h = _vm.$createElement
var _c = _vm._self._c || _h // 使用 _self._c（可能是 _vm._self._c），如果不存在则使用 _h 来创建虚拟节点 var _c = _vm._self._c || _h
} }
// 定义 recyclableRender 变量，表示是否启用可回收渲染
// 这个标志用于优化组件的渲染性能，当设置为 true 时，表示启用可回收渲染。
var recyclableRender = false var recyclableRender = false
// 定义静态渲染函数列表，通常用于静态部分的渲染优化
var staticRenderFns = [] var staticRenderFns = []
// 设置 _withStripped 属性为 true，表示在打包时已去除了模板中的指令和处理（如 v-if、v-for等），
// 用于优化渲染性能，确保不会无用的代码出现在最终打包的代码中
render._withStripped = true render._withStripped = true
@ -148,34 +114,25 @@ __webpack_require__.r(__webpack_exports__);
/***/ (function(module, exports, __webpack_require__) { /***/ (function(module, exports, __webpack_require__) {
"use strict"; "use strict";
Object.defineProperty(exports, "__esModule", { value: true });exports.default = void 0; //
// 使用严格模式，帮助捕获潜在的错误并确保代码更安全 //
//
// 使用 Object.defineProperty 定义一个模块导出，确保模块的导出是 ES6 的标准模块导出 //
Object.defineProperty(exports, "__esModule", { value: true }); //
exports.default = void 0; // 导出默认值，这里默认值是一个 Vue 组件的配置对象 //
//
// Vue 组件的定义 //
var _default = { var _default =
// data 方法返回该组件的数据对象 {
data: function data() { data: function data() {
// 返回一个空对象，表示该组件没有特定的数据属性
return {}; return {};
},
// 定义该组件的 props（外部传递给组件的属性）
},
props: { props: {
// 定义一个名为 loadingText 的 prop
loadingText: { loadingText: {
type: String, // prop 的类型是 String type: String,
default: '' // 默认值为空字符串 default: '' } } };exports.default = _default;
}
}
};
// 将默认的 Vue 组件配置对象导出
exports.default = _default;
/***/ }), /***/ }),
@ -210,18 +167,12 @@ __webpack_require__.r(__webpack_exports__);
}]); }]);
//# sourceMappingURL=../../../.sourcemap/mp-weixin/components/reach-bottom/reach-bottom.js.map //# sourceMappingURL=../../../.sourcemap/mp-weixin/components/reach-bottom/reach-bottom.js.map
;// 确保 `webpackJsonp` 数组存在并初始化（如果尚未初始化），并推送一个新的模块配置 ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
(global["webpackJsonp"] = global["webpackJsonp"] || []).push([ 'components/reach-bottom/reach-bottom-create-component',
'components/reach-bottom/reach-bottom-create-component', // 模块的唯一标识符
{ {
// 定义模块的实际实现
'components/reach-bottom/reach-bottom-create-component':(function(module, exports, __webpack_require__){ 'components/reach-bottom/reach-bottom-create-component':(function(module, exports, __webpack_require__){
// 引入依赖的模块，并调用其中的 `createComponent` 方法，创建一个组件 __webpack_require__('1')['createComponent'](__webpack_require__(90))
__webpack_require__('1')['createComponent'](__webpack_require__(90)); // `__webpack_require__(1)` 引入第 1 模块，调用其 `createComponent` 方法，并传入 `__webpack_require__(90)` 作为参数
}) })
}, },
// 依赖的模块数组，确保模块被正确加载
[['components/reach-bottom/reach-bottom-create-component']] [['components/reach-bottom/reach-bottom-create-component']]
]); ]);

157
user/mp-weixin/components/uni-icons/uni-icons.js
Unescape View File

@ -23,36 +23,16 @@ var renderjs
/* normalize component */ /* normalize component */
// 调用 Vue 组件的规范化方法，以便将 `uni-icons` 组件正常注册和渲染
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
// 第一个参数是组件的脚本部分，即 `uni-icons` 组件的 JavaScript 逻辑
_uni_icons_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _uni_icons_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 第二个参数是组件的 `render` 函数，描述如何渲染组件的视图（模板部分）
_uni_icons_vue_vue_type_template_id_0bf90c00_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _uni_icons_vue_vue_type_template_id_0bf90c00_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 第三个参数是 `staticRenderFns`，表示静态渲染函数（通常用于静态部分的模板）
_uni_icons_vue_vue_type_template_id_0bf90c00_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _uni_icons_vue_vue_type_template_id_0bf90c00_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 第四个参数 `false` 表示该组件不是异步组件，且不需要延迟加载
false, false,
// 第五个参数 `null` 是针对样式的作用域标识，表示该组件不使用样式作用域
null, null,
// 第六个参数 `"0bf90c00"` 是组件的唯一标识符，用于标识该组件在构建时的标识码
"0bf90c00", "0bf90c00",
// 第七个参数 `null` 可能是针对组件传递的额外配置（此处没有额外配置）
null, null,
// 第八个参数 `false` 表示该组件没有开启服务器端渲染（SSR）相关的功能
false, false,
_uni_icons_vue_vue_type_template_id_0bf90c00_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// 第九个参数是该组件的子组件，定义了该组件中可能使用的其他子组件
_uni_icons_vue_vue_type_template_id_0bf90c00_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"]
,
renderjs renderjs
) )
@ -90,47 +70,21 @@ __webpack_require__.r(__webpack_exports__);
/*! exports provided: render, staticRenderFns, recyclableRender, components */ /*! exports provided: render, staticRenderFns, recyclableRender, components */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict"; // 使用严格模式，避免一些常见的错误（如变量未声明等） "use strict";
__webpack_require__.r(__webpack_exports__); // 通知 Webpack 当前模块为一个 ES模块（用于模块的导出和导入） __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "render", function() { return render; });
/* harmony export (binding) */ /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
__webpack_require__.d(__webpack_exports__, "render", function() { return render; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
// 将 `render` 函数导出为模块的一个绑定项，供外部访问。 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
var components
/* harmony export (binding) */
__webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
// 将 `staticRenderFns` 函数导出为模块的一个绑定项，供外部访问。
/* harmony export (binding) */
__webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
// 将 `recyclableRender` 标记导出，用于指示该组件是否可以进行回收渲染。
/* harmony export (binding) */
__webpack_require__.d(__webpack_exports__, "components", function() { return components; });
// 将 `components` 导出，表示组件所依赖的子组件。
// 定义组件所依赖的子组件（此处暂未赋值）
var components;
// 组件的渲染函数
var render = function() { var render = function() {
var _vm = this; // 获取 Vue 实例（即当前组件的上下文） var _vm = this
var _h = _vm.$createElement; // 获取 Vue 的创建元素方法，用于创建虚拟 DOM var _h = _vm.$createElement
var _c = _vm._self._c || _h; // 如果 `_self._c` 存在，则使用 `_self._c`，否则使用 `_h`。这个函数通常用于生成虚拟 DOM。 var _c = _vm._self._c || _h
}
// 注意：此处 `render` 函数并未执行任何实际的渲染逻辑，通常该函数会返回虚拟 DOM var recyclableRender = false
}; var staticRenderFns = []
render._withStripped = true
// 标记是否可以回收渲染
var recyclableRender = false; // 当前组件不可回收渲染。通常用来优化渲染性能，在某些条件下，可以避免重新渲染已渲染的部分。
// 静态渲染函数，通常用于渲染不变的内容以提高性能
var staticRenderFns = []; // 当前没有静态渲染函数，空数组表示没有静态内容。
// `render._withStripped = true` 表示 Vue 在生成编译器代码时，去除了 `render` 函数中的注释等调试信息。
// 这有助于提高构建后的性能，去除冗余的调试代码。
render._withStripped = true;
@ -159,59 +113,45 @@ __webpack_require__.r(__webpack_exports__);
/*! no static exports found */ /*! no static exports found */
/***/ (function(module, exports, __webpack_require__) { /***/ (function(module, exports, __webpack_require__) {
"use strict"; // 使用严格模式，帮助捕获常见错误，并禁止一些不安全的代码行为 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });exports.default = void 0;
// 定义模块导出
Object.defineProperty(exports, "__esModule", { value: true }); // 确保模块以 ES6 模块的方式导出
exports.default = void 0; // 导出默认值，暂时设为 undefined
// 导入外部文件，获取包含图标数据的模块
var _icons = _interopRequireDefault(__webpack_require__(/*! ./icons.js */ 237));
// 辅助函数，用于处理默认导入 var _icons = _interopRequireDefault(__webpack_require__(/*! ./icons.js */ 237));function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };} //
function _interopRequireDefault(obj) { //
return obj && obj.__esModule ? obj : { default: obj }; // 如果 obj 已经是 ES6 模块，直接返回；否则包裹成一个对象并加上默认导出 //
} //
var _default =
// 默认导出的对象（Vue 组件）
var _default = {
name: 'UniIcons', // 定义组件的名称为 UniIcons
// 组件的 props（即父组件传入的数据） {
name: 'UniIcons',
props: { props: {
type: { // `type` prop 用于传递图标的类型 type: {
type: String, // 类型为 String type: String,
default: '' // 默认值为空字符串 default: '' },
},
color: { // `color` prop 用于设置图标的颜色 color: {
type: String, // 类型为 String type: String,
default: '#333333' // 默认颜色为 #333333（深灰色） default: '#333333' },
},
size: {
type: [Number, String],
default: 16 } },
size: { // `size` prop 用于设置图标的大小
type: [Number, String], // 支持 Number 或 String 类型
default: 16 // 默认大小为 16
}
},
// 组件的 data（即组件内部的数据）
data: function data() { data: function data() {
return { return {
icons: _icons.default // 从 `_icons` 模块中导入的图标数据作为组件的数据源 icons: _icons.default };
};
},
// 组件的方法 },
methods: { methods: {
_onClick: function _onClick() { // 定义点击事件处理方法 _onClick: function _onClick() {
this.$emit('click'); // 触发自定义的 `click` 事件，将事件发送到父组件 this.$emit('click');
} } } };exports.default = _default;
}
};
// 导出该 Vue 组件作为默认导出
exports.default = _default;
/***/ }), /***/ }),
@ -246,23 +186,12 @@ __webpack_require__.r(__webpack_exports__);
}]); }]);
//# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-icons/uni-icons.js.map //# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-icons/uni-icons.js.map
;// 将 `webpackJsonp` 数组初始化或推入新元素 ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
// 推入的模块名称（这个是组件的模块名称）
'components/uni-icons/uni-icons-create-component', 'components/uni-icons/uni-icons-create-component',
// 模块的内容：这是一个对象，表示要处理的模块
{ {
'components/uni-icons/uni-icons-create-component':(function(module, exports, __webpack_require__){ 'components/uni-icons/uni-icons-create-component':(function(module, exports, __webpack_require__){
// 在这里调用了 `createComponent` 方法，注册组件 __webpack_require__('1')['createComponent'](__webpack_require__(232))
// `__webpack_require__('1')` 加载模块 '1'，通常是一个包含 `createComponent` 方法的模块
// 然后使用 `createComponent` 方法创建并注册位于路径 232 的组件（即 `uni-icons` 组件）
__webpack_require__('1')['createComponent'](__webpack_require__(232));
}) })
}, },
// 这里表示当前模块的依赖数组，确保依赖被正确加载。这个数组内包含了 `components/uni-icons/uni-icons-create-component`。
[['components/uni-icons/uni-icons-create-component']] [['components/uni-icons/uni-icons-create-component']]
]); ]);

82
user/mp-weixin/components/uni-nav-bar/uni-nav-bar.js
Unescape View File

@ -23,47 +23,22 @@ var renderjs
/* normalize component */ /* normalize component */
// 引入 `componentNormalizer`，用于标准化组件创建的过程
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
// 第一个参数是组件的脚本部分，通常包含组件的逻辑和数据。这里引用的是 `_uni_nav_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"]`。
_uni_nav_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _uni_nav_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 第二个参数是组件的渲染函数，通常是用来定义模板如何转化为真实的 DOM。引用的是模板部分的 `render` 函数。
_uni_nav_bar_vue_vue_type_template_id_4afea59e_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _uni_nav_bar_vue_vue_type_template_id_4afea59e_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 第三个参数是组件的静态渲染函数，通常用于静态内容的渲染，提升渲染性能。
_uni_nav_bar_vue_vue_type_template_id_4afea59e_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _uni_nav_bar_vue_vue_type_template_id_4afea59e_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 第四个参数是一个布尔值，指示是否要进行开发模式下的调试。此处是 `false`，表示不开启调试。
false, false,
// 第五个参数是一个 `null`，该位置可以指定组件的生命周期钩子，但这里没有特殊设置。
null, null,
// 第六个参数是一个组件的作用域 ID，通常用于 scoped CSS。这里的 `4afea59e` 是该组件的唯一标识符。
"4afea59e", "4afea59e",
// 第七个参数是 `null`，在此处指定组件的父级上下文，但这里没有特殊设置。
null, null,
// 第八个参数是一个布尔值，指示该组件是否进行模块热更新。此处是 `false`，表示不需要。
false, false,
// 第九个参数是组件的 `components` 属性，包含该组件所依赖的子组件列表，通常是其他 Vue 组件。这里引用的是模板部分的 `components`。
_uni_nav_bar_vue_vue_type_template_id_4afea59e_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _uni_nav_bar_vue_vue_type_template_id_4afea59e_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// `renderjs` 是一个附加的渲染逻辑（通常在复杂的组件中使用），可以通过此字段传递给组件。
renderjs renderjs
); )
// 设置组件的 `__file` 属性，表示该组件对应的源文件路径，便于调试和开发工具识别文件。
component.options.__file = "components/uni-nav-bar/uni-nav-bar.vue" component.options.__file = "components/uni-nav-bar/uni-nav-bar.vue"
// 将标准化后的组件导出，作为模块的默认导出，其他模块可以通过此导入该组件。
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);
/***/ }), /***/ }),
/***/ 146: /***/ 146:
@ -101,77 +76,44 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
// 定义一个 `components` 变量，用于存储动态加载的组件 var components
var components;
try { try {
// 尝试定义 `components` 对象，其中包含两个动态加载的组件
components = { components = {
// `uniStatusBar` 组件：这是一个动态导入的组件
uniStatusBar: function() { uniStatusBar: function() {
// 使用 Webpack 的 `import()` 函数来动态加载组件 return __webpack_require__.e(/*! import() | components/uni-status-bar/uni-status-bar */ "components/uni-status-bar/uni-status-bar").then(__webpack_require__.bind(null, /*! @/components/uni-status-bar/uni-status-bar.vue */ 225))
// `__webpack_require__.e` 触发异步加载，加载 `components/uni-status-bar/uni-status-bar` 这个组件的相关代码
return __webpack_require__.e(/*! import() | components/uni-status-bar/uni-status-bar */ "components/uni-status-bar/uni-status-bar")
// 在加载完成后，使用 `__webpack_require__.bind` 动态引入对应的 `.vue` 文件
.then(__webpack_require__.bind(null, /*! @/components/uni-status-bar/uni-status-bar.vue */ 225))
}, },
// `uniIcons` 组件：这是另一个动态导入的组件
uniIcons: function() { uniIcons: function() {
// 使用 Webpack 的 `import()` 函数加载 `components/uni-icons/uni-icons` 组件，并且还会加载公共依赖（`common/vendor`） return Promise.all(/*! import() | components/uni-icons/uni-icons */[__webpack_require__.e("common/vendor"), __webpack_require__.e("components/uni-icons/uni-icons")]).then(__webpack_require__.bind(null, /*! @/components/uni-icons/uni-icons.vue */ 232))
return Promise.all(/*! import() | components/uni-icons/uni-icons */[
__webpack_require__.e("common/vendor"), // 加载公共依赖部分
__webpack_require__.e("components/uni-icons/uni-icons") // 加载 `uni-icons` 组件
])
// 在加载完成后，使用 `__webpack_require__.bind` 导入 `uni-icons` 的 `.vue` 文件
.then(__webpack_require__.bind(null, /*! @/components/uni-icons/uni-icons.vue */ 232))
} }
} }
} catch (e) { } catch (e) {
// 如果出现错误，捕获并处理错误
if ( if (
e.message.indexOf("Cannot find module") !== -1 && // 如果错误消息中包含“无法找到模块” e.message.indexOf("Cannot find module") !== -1 &&
e.message.indexOf(".vue") !== -1 // 并且是与 `.vue` 文件相关的错误 e.message.indexOf(".vue") !== -1
) { ) {
// 输出错误信息
console.error(e.message) console.error(e.message)
console.error("1. 排查组件名称拼写是否正确") // 提示检查组件名称是否拼写正确 console.error("1. 排查组件名称拼写是否正确")
console.error( console.error(
"2. 排查组件是否符合 easycom 规范，文档：https://uniapp.dcloud.net.cn/collocation/pages?id=easycom" "2. 排查组件是否符合 easycom 规范，文档：https://uniapp.dcloud.net.cn/collocation/pages?id=easycom"
) // 提示检查组件是否符合 EasyCom 规范 )
console.error( console.error(
"3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件" "3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件"
) // 提示若不符合规范，则需要手动引入并注册组件 )
} else { } else {
// 如果错误不是上述类型的错误，则重新抛出错误
throw e throw e
} }
} }
// 定义 `render` 函数，用于生成虚拟 DOM 树
var render = function() { var render = function() {
var _vm = this // `this` 是当前 Vue 实例，指向当前组件 var _vm = this
var _h = _vm.$createElement // 获取 Vue 实例的 `$createElement` 方法，用于创建虚拟 DOM 元素 var _h = _vm.$createElement
var _c = _vm._self._c || _h // `_c` 是用于创建虚拟 DOM 元素的简写，优先使用 `_vm._self._c`，否则使用 `_h`，两者都指向 `$createElement` var _c = _vm._self._c || _h
} }
// `recyclableRender` 标记是否启用可回收的渲染函数，默认为 `false`
// 在 Vue 中，启用可回收渲染时，Vue 会复用渲染函数，提高性能
var recyclableRender = false var recyclableRender = false
// `staticRenderFns` 是静态渲染函数的数组，通常用于静态内容的渲染优化
// 如果组件中包含静态部分，Vue 会将它们提取成静态渲染函数以提高渲染性能
var staticRenderFns = [] var staticRenderFns = []
// `render._withStripped = true` 是 Vue 编译器的标志，用于表示该渲染函数已经通过编译器去除了代码注释
// 这个标记通常用于优化代码，去除不必要的注释以减少体积
render._withStripped = true render._withStripped = true
/***/ }), /***/ }),
/***/ 148: /***/ 148:

110
user/mp-weixin/components/uni-phone/index.js
Unescape View File

@ -23,50 +23,22 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 `Object` 调用 `_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"]`
// 来规范化 Vue 组件的导出。该函数会处理 Vue 组件的多个功能，并返回一个处理后的组件对象。
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
// `_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"]`：加载 Vue 组件的脚本部分，包含组件的逻辑。
_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// `_index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"]`：加载该 Vue 组件的渲染函数。
// 渲染函数用于生成组件的虚拟 DOM。
_index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// `_index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"]`：加载该组件的静态渲染函数。
// 静态渲染函数用于渲染不依赖于数据的部分，通常用于提升性能。
_index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 第四个参数 `false` 表示该组件不启用热更新。热更新用于开发环境中实时更新页面而不重新加载页面。
false, false,
// `null`：组件没有使用任何特殊的生命周期钩子或事件
null, null,
// `"0b00c929"`：组件的唯一 ID，用于 Vue 组件的样式作用域。
"0b00c929", "0b00c929",
// `null`：未指定额外的 props 或方法，可能是用作组件的插槽。
null, null,
// 第一个 `false`：表明该组件不允许异步渲染或插槽。
false, false,
// `_index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"]`：这是该组件所依赖的其他子组件。
_index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _index_vue_vue_type_template_id_0b00c929_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// `renderjs`：用于渲染该组件的 JavaScript 代码。通常 `renderjs` 是动态生成的，用于处理组件的特殊渲染逻辑。
renderjs renderjs
) )
// 设置组件的文件路径，帮助开发工具识别该文件的位置。
component.options.__file = "components/uni-phone/index.vue" component.options.__file = "components/uni-phone/index.vue"
// 使用 `harmony default export` 将组件的最终导出作为默认导出，允许其他模块直接导入此组件。
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);
/***/ }), /***/ }),
/***/ 139: /***/ 139:
@ -104,58 +76,41 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
// 定义一个 `components` 变量用于存储动态引入的组件
var components var components
try { try {
// 使用动态 import 加载 `uniPopup` 组件
components = { components = {
uniPopup: function() { uniPopup: function() {
// 通过 Webpack 的代码拆分机制，动态加载 `uni-popup` 组件 return __webpack_require__.e(/*! import() | uni_modules/uni-popup/components/uni-popup/uni-popup */ "uni_modules/uni-popup/components/uni-popup/uni-popup").then(__webpack_require__.bind(null, /*! @/uni_modules/uni-popup/components/uni-popup/uni-popup.vue */ 166))
// `__webpack_require__.e()` 用来加载组件的代码块，`"uni_modules/uni-popup/components/uni-popup/uni-popup"` 是代码块的名称
return __webpack_require__.e(/*! import() | uni_modules/uni-popup/components/uni-popup/uni-popup */ "uni_modules/uni-popup/components/uni-popup/uni-popup")
// 加载成功后，使用 `__webpack_require__.bind()` 来引入 `uni-popup.vue` 组件文件
.then(__webpack_require__.bind(null, /*! @/uni_modules/uni-popup/components/uni-popup/uni-popup.vue */ 166))
} }
} }
} catch (e) { } catch (e) {
// 捕获错误并处理
if ( if (
e.message.indexOf("Cannot find module") !== -1 && // 错误信息中包含 "Cannot find module" 表示模块加载失败 e.message.indexOf("Cannot find module") !== -1 &&
e.message.indexOf(".vue") !== -1 // 错误信息中包含 ".vue" 表示尝试加载 Vue 文件时失败 e.message.indexOf(".vue") !== -1
) { ) {
console.error(e.message) // 输出错误信息 console.error(e.message)
console.error("1. 排查组件名称拼写是否正确") // 提示开发者检查组件名称拼写是否正确 console.error("1. 排查组件名称拼写是否正确")
console.error( console.error(
"2. 排查组件是否符合 easycom 规范，文档：https://uniapp.dcloud.net.cn/collocation/pages?id=easycom" "2. 排查组件是否符合 easycom 规范，文档：https://uniapp.dcloud.net.cn/collocation/pages?id=easycom"
) // 提示开发者检查组件是否符合 Easycom 规范，可以参考文档 )
console.error( console.error(
"3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件" "3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件"
) // 提示开发者手动引入组件，并在 `components` 中注册 )
} else { } else {
throw e // 如果错误不是与模块加载有关，抛出该错误 throw e
} }
} }
// 定义 `render` 函数，负责渲染 Vue 组件
var render = function() { var render = function() {
var _vm = this // `this` 代表当前 Vue 实例 var _vm = this
var _h = _vm.$createElement // 获取 Vue 实例中的 `$createElement` 方法，用于创建虚拟 DOM var _h = _vm.$createElement
var _c = _vm._self._c || _h // 备用方式，确保有一个创建元素的函数 var _c = _vm._self._c || _h
} }
// 定义 `recyclableRender` 变量，控制是否启用可回收渲染
var recyclableRender = false var recyclableRender = false
// `staticRenderFns` 用于存储静态渲染函数，在模板中只依赖静态数据的部分会使用静态渲染函数
var staticRenderFns = [] var staticRenderFns = []
// `render._withStripped = true`：该标志指示 Vue 是否应该在模板编译时移除代码中的 `with` 语法，优化生成的代码
render._withStripped = true render._withStripped = true
/***/ }), /***/ }),
/***/ 141: /***/ 141:
@ -211,55 +166,24 @@ var _index = __webpack_require__(/*! ../../utils/index.js */ 29); //
// //
// //
// //
// 定义一个默认的 Vue 组件对象，包含 data、props 和 methods 等部分 var _default = { data: function data() {return {};}, props: { phoneData: { type: String, default: "" } }, methods: { // 电话号码拨打
var _default = { call: function call() {// 暂时关闭打电话
// data 函数，返回组件的响应式数据对象 (0, _index.call)(this.phoneData);
data: function data() {
return {}; // 当前组件没有定义任何响应式数据，返回一个空对象
}, },
// props 定义父组件传递给当前组件的属性
props: {
phoneData: {
type: String, // phoneData 属性的类型为字符串
default: "" // 如果父组件没有传递 phoneData，默认值为空字符串
}
},
// methods 定义当前组件的方法
methods: {
// 电话号码拨打方法
call: function call() {
// 暂时关闭打电话功能
// (0, _index.call)(this.phoneData); // 此行代码被注释掉，暂时不执行打电话功能
},
// 关闭弹出框方法
closePopup: function closePopup() { closePopup: function closePopup() {
// 通过 $emit 触发 'closePopup' 事件，通知父组件关闭弹出框
this.$emit('closePopup'); this.$emit('closePopup');
} } } };exports.default = _default;
}
};
// 导出组件对象，使其可以被外部引用
exports.default = _default;
/***/ }) /***/ })
}]); }]);
//# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-phone/index.js.map //# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-phone/index.js.map
// 以下是 Webpack 代码拆分生成的代码，用于创建组件实例
;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([ ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
'components/uni-phone/index-create-component', 'components/uni-phone/index-create-component',
{ {
// 动态加载组件并创建组件实例
'components/uni-phone/index-create-component':(function(module, exports, __webpack_require__){ 'components/uni-phone/index-create-component':(function(module, exports, __webpack_require__){
// 使用 Webpack 提供的 createComponent 方法创建组件实例 __webpack_require__('1')['createComponent'](__webpack_require__(138))
__webpack_require__('1')['createComponent'](__webpack_require__(138)) // 加载组件模块并创建组件
}) })
}, },
[['components/uni-phone/index-create-component']] // 组件的创建模块 [['components/uni-phone/index-create-component']]
]); ]);

176
user/mp-weixin/components/uni-piker/index.js
Unescape View File

@ -23,46 +23,21 @@ var renderjs
/* normalize component */ /* normalize component */
// 通过运行时的 `componentNormalizer` 方法来正常化 Vue 组件的结构
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
// 引入组件的脚本部分，通常包括了组件的逻辑代码、data、methods 等
_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 引入组件的模板部分，负责定义该组件的 HTML 结构
_index_vue_vue_type_template_id_7d30bc3a_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _index_vue_vue_type_template_id_7d30bc3a_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 引入静态渲染函数，通常是与模板相关的静态部分（例如静态内容和样式）
_index_vue_vue_type_template_id_7d30bc3a_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _index_vue_vue_type_template_id_7d30bc3a_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 表示该组件是否开启 `functional` 模式，`false` 代表不是函数式组件
false, false,
// 该参数用于配置作用域样式，`null` 代表没有特殊的作用域样式配置
null, null,
// 该参数是作用域 ID，通常用于样式作用域的命名空间，"7d30bc3a" 是该组件的作用域标识符
"7d30bc3a", "7d30bc3a",
// 该参数表示是否开启热重载功能，`null` 通常表示默认设置
null, null,
// 设置是否启用 `scoped` 样式，`false` 表示没有作用域样式
false, false,
// 引入该组件使用的子组件
_index_vue_vue_type_template_id_7d30bc3a_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _index_vue_vue_type_template_id_7d30bc3a_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// 引入组件的 JavaScript 渲染逻辑
renderjs renderjs
); )
// 设置 `component` 对象的 `__file` 属性，指定该组件的源文件路径
component.options.__file = "components/uni-piker/index.vue";
/* harmony default export */
// 导出组件对象，使其可以在其他地方引用
__webpack_exports__["default"] = (component.exports);
component.options.__file = "components/uni-piker/index.vue"
/* harmony default export */ __webpack_exports__["default"] = (component.exports);
/***/ }), /***/ }),
@ -95,44 +70,21 @@ __webpack_require__.r(__webpack_exports__);
/*! exports provided: render, staticRenderFns, recyclableRender, components */ /*! exports provided: render, staticRenderFns, recyclableRender, components */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict"; // 使用严格模式，禁止一些不安全的 JavaScript 行为，如变量声明必须明确 "use strict";
// 导出模块接口的设置，确保 `__webpack_require__.r(__webpack_exports__);` 在模块中标记为 ES6 模块
__webpack_require__.r(__webpack_exports__); __webpack_require__.r(__webpack_exports__);
// 导出 `render` 函数，使它可以在其他模块中使用
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "render", function() { return render; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "render", function() { return render; });
// 导出 `staticRenderFns`，它通常包含静态渲染函数，用于优化静态内容渲染
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
// 导出 `recyclableRender`，标识该组件的渲染是否可回收，优化性能
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
// 导出 `components`，通常包含该组件所依赖的子组件
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
var components
// 声明一个空变量 `components`，它将来可能会被赋值为子组件的引用
var components;
// 定义组件的 `render` 函数，这里是一个模板渲染函数的占位符
// `_vm` 是 Vue 组件的实例，`_h` 是 Vue 的创建元素方法，`_c` 是 `createElement` 的快捷方式
var render = function() { var render = function() {
var _vm = this; // 当前组件的 Vue 实例 var _vm = this
var _h = _vm.$createElement; // `createElement` 方法，Vue 用于创建虚拟 DOM 节点 var _h = _vm.$createElement
var _c = _vm._self._c || _h; // `createElement` 是 `_self._c` 或者 `_h`，为兼容性处理 var _c = _vm._self._c || _h
}; }
var recyclableRender = false
// `recyclableRender` 是一个标识符，指示组件的渲染是否是可回收的，通常用于优化性能 var staticRenderFns = []
// 设置为 `false` 表示渲染不可回收，可能导致不做性能优化 render._withStripped = true
var recyclableRender = false;
// `staticRenderFns` 是存储静态渲染函数的数组，通常包含组件模板中没有变化的静态部分
var staticRenderFns = [];
// `render._withStripped = true` 标记该渲染函数已经被去除了一些开发时的辅助代码，比如注释等
render._withStripped = true; // 表示这个渲染函数已经经过“精简”处理，不包含开发环境的调试信息
@ -184,92 +136,75 @@ Object.defineProperty(exports, "__esModule", { value: true });exports.default =
// //
// //
// //
var _default = { var _default =
// 组件的 props 属性，定义了父组件传递给当前组件的数据 {
props: ['baseData'], // 父组件传入的数据，这里是 baseData props: ['baseData'],
// 组件的 data 方法，用来返回组件的局部状态
data: function data() { data: function data() {
return { return {
// selectscooldata 用来存储用户选择的数据
selectscooldata: {}, selectscooldata: {},
// title 用于显示当前组件的标题
title: 'picker-view', title: 'picker-view',
// baseData:5,
// indicatorStyle 是样式设置，用来控制 picker-view 中指示器的样式
indicatorStyle: "height: 50px;", indicatorStyle: "height: 50px;",
defaultValue: [0] //默认选中hoverhover中下标为2的那个元素
// defaultValue 设置 picker-view 默认选中的值，默认是下标为 0 的元素 //defaultValue是默认展示的值，你要注意，如果hoverhover是动态循环出来时，你在data中直接给默认值，可能不能够显示你想要展示的值
defaultValue: [0]
// 默认选中下标为 0 的值，可以在外部传入 baseData 来动态改变默认值
}; };
}, },
// 组件的方法
methods: { methods: {
// pickstart 方法，表示 picker-view 开始选择时的事件处理
pickstart: function pickstart() { pickstart: function pickstart() {
console.log(1); // 打印 1，表示用户开始选择 console.log(1);
}, },
/** /**
* bindChange 方法，处理 picker-view 中选择值变化的事件 * uniapp中，向上传递值得时候，不要在关闭事件中进行传递值；
* @param {Object} e - 事件对象 * 因为关闭事件中有可能形成异步(造成选择的值和页面显示的值不一致这个问题)
*/ * 使用change事件将值抛出去
* */
bindChange: function bindChange(e) { bindChange: function bindChange(e) {
this.selectscooldata = e; // 将事件对象赋值给 selectscooldata this.selectscooldata = e;
console.log(this.baseData[e.detail.value[0]]); // 打印当前选择的 baseData 项 console.log(this.baseData[e.detail.value[0]]);
if (e.detail && e.detail.value) { if (e.detail && e.detail.value) {
// 如果有选择的值，实时将用户选择的值抛出去 //实时将用户选择的值抛出去
var val = e.detail.value[0]; // 获取用户选择的第一个值（下标）
this.$emit('changeCont', this.baseData[e.detail.value[0]]); // 通过 $emit 触发父组件的 'changeCont' 事件，并传递选中的值 var val = e.detail.value[0];
this.tablewareData = this.baseData[e.detail.value[0]]; // 保存选中的数据到 tablewareData 变量 this.$emit('changeCont', this.baseData[e.detail.value[0]]);
// this.$emit('changeCont', e.detail.value[0]) // 可选：触发父组件事件传递下标值 this.tablewareData = this.baseData[e.detail.value[0]];
this.$emit('changeCont', this.tablewareData); // 再次触发父组件事件传递选中的数据 // this.$emit('changeCont',e.detail.value[0])
this.$emit('changeCont', this.tablewareData);
} else { } else {
// 如果没有选择值，说明用户选择了默认值 this.$emit('changeCont', this.baseData[e.detail.value[0]]);
this.$emit('changeCont', this.baseData[e.detail.value[0]]); // 触发父组件事件，传递默认值 this.tablewareData = this.baseData[e.detail.value[0]];
this.tablewareData = this.baseData[e.detail.value[0]]; // 保存默认数据到 tablewareData // this.$emit('changeCont',e.detail.value[0])
// this.$emit('changeCont', e.detail.value[0]) // 可选：触发父组件事件传递下标值 // 用户没有滚动，说明用户选择的是我们给用户展示的默认值
this.$emit('changeCont', this.tablewareData); // 触发父组件事件传递选中的数据（默认值） this.$emit('changeCont', this.tablewareData);
} }
}, },
// date 方法，用于打开 picker-view
date: function date(e) { date: function date(e) {
this.$refs.onlyhover.open(); // 通过 refs 引用调用 onlyhover 组件的 open 方法 this.$refs.onlyhover.open();
}, },
// fatheropen 方法，调用 refs 引用的 onlyhover 组件的 open 方法
fatheropen: function fatheropen() { fatheropen: function fatheropen() {
this.$refs.onlyhover.open(); // 打开 picker-view this.$refs.onlyhover.open();
}, },
// fathClose 方法，调用 refs 引用的 onlyhover 组件的 close 方法
fathClose: function fathClose() { fathClose: function fathClose() {
this.$refs.onlyhover.close(); // 关闭 picker-view this.$refs.onlyhover.close();
}, },
/** /**
* closemask 方法，处理用户点击确认时的事件 * 确认按钮，没有值得时候去寻找默认值
* 如果用户没有选择值，则使用默认值 * */
*/
closemask: function closemask() { closemask: function closemask() {
if (this.selectscooldata.detail && this.selectscooldata.detail.value) { if (this.selectscooldata.detail && this.selectscooldata.detail.value) {
// 如果用户选择了值，什么也不做（值已经传递到父组件） //
} else { } else {
// 用户没有选择任何值，使用默认值 //此时用户选择的是默认值，在点击的时候抛出去
var cont = this.baseData[this.defaultValue[0]]; // 获取默认值 var cont = this.baseData[this.defaultValue[0]];
this.$emit('changeCont', cont); // 将默认值传递给父组件 this.$emit('changeCont', cont);
}
} }
}
};
exports.default = _default;
} } };exports.default = _default;
/***/ }), /***/ }),
@ -304,21 +239,12 @@ __webpack_require__.r(__webpack_exports__);
}]); }]);
//# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-piker/index.js.map //# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-piker/index.js.map
;// 使用 webpack 动态加载组件，`webpackJsonp` 是 webpack 中用于管理异步模块的机制 ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
// 组件的名称，这里是 'components/uni-piker/index-create-component'
'components/uni-piker/index-create-component', 'components/uni-piker/index-create-component',
// 模块定义部分
{ {
'components/uni-piker/index-create-component':(function(module, exports, __webpack_require__){ 'components/uni-piker/index-create-component':(function(module, exports, __webpack_require__){
// `__webpack_require__` 用于加载其他模块，'1' 是一个模块标识符 __webpack_require__('1')['createComponent'](__webpack_require__(180))
// 通过 `createComponent` 创建组件并将其挂载到指定位置
__webpack_require__('1')['createComponent'](__webpack_require__(180));
}) })
}, },
// 依赖模块，这里指定了组件依赖的模块
[['components/uni-piker/index-create-component']] [['components/uni-piker/index-create-component']]
]) ]);
;

145
user/mp-weixin/components/uni-popup/index.js
Unescape View File

@ -8,78 +8,37 @@
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict"; "use strict";
// `__webpack_require__.r(__webpack_exports__);` 用于标记当前模块为 ES6 模块，这样可以使得它支持 ES6 的模块导出形式。
// 这是一种 Webpack 内部使用的机制，确保模块的导出与导入正确工作。
__webpack_require__.r(__webpack_exports__); __webpack_require__.r(__webpack_exports__);
// 导入 `index.vue` 模板部分。模板部分是 Vue 组件的结构，通常包含 HTML 模板。
/* harmony import */ var _index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index.vue?vue&type=template&id=7b78f232& */ 188); /* harmony import */ var _index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index.vue?vue&type=template&id=7b78f232& */ 188);
// 导入 `index.vue` 中的 JavaScript 脚本部分。脚本部分定义了 Vue 组件的逻辑，例如生命周期钩子、数据、方法等。
// `lang=js` 表示该文件是 JavaScript 代码。
/* harmony import */ var _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index.vue?vue&type=script&lang=js& */ 190); /* harmony import */ var _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index.vue?vue&type=script&lang=js& */ 190);
/* harmony reexport (unknown) */ for(var __WEBPACK_IMPORT_KEY__ in _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__) if(__WEBPACK_IMPORT_KEY__ !== 'default') (function(key) { __webpack_require__.d(__webpack_exports__, key, function() { return _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__[key]; }) }(__WEBPACK_IMPORT_KEY__));
// 将 `index.vue` 脚本部分的所有导出重新导出到当前模块中。
// `for (var __WEBPACK_IMPORT_KEY__ in ...)` 是用于遍历脚本部分的所有导出，并确保它们都能够被当前模块导出。
// `if(__WEBPACK_IMPORT_KEY__ !== 'default')` 排除 `default` 导出，确保其他命名导出也能正确地传递到当前模块。
// 这样可以将 `index.vue` 中的命名导出映射到当前模块中，使得其他模块可以通过 ES6 的方式使用它们。
/* harmony reexport (unknown) */ for(var __WEBPACK_IMPORT_KEY__ in _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__)
if(__WEBPACK_IMPORT_KEY__ !== 'default')
(function(key) {
__webpack_require__.d(__webpack_exports__, key, function() { return _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__[key]; })
}(__WEBPACK_IMPORT_KEY__));
// 导入 `index.vue` 的样式部分，这里样式采用了 `scss` 预处理器。
// `lang=scss` 表示该文件使用的是 SCSS 语言，用于定义组件的样式。
/* harmony import */ var _index_vue_vue_type_style_index_0_lang_scss___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index.vue?vue&type=style&index=0&lang=scss& */ 192); /* harmony import */ var _index_vue_vue_type_style_index_0_lang_scss___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index.vue?vue&type=style&index=0&lang=scss& */ 192);
// 导入 `componentNormalizer.js`，这是一个 Vue 组件的标准化工具。
// 它的作用是确保组件在 Vue 中的创建和注册过程是标准的，能够处理 Vue 组件的跨平台兼容性问题。
// `componentNormalizer.js` 是由 `@dcloudio/vue-cli-plugin-uni` 插件提供的，用于确保 UniApp 组件在不同平台下的一致性。
/* harmony import */ var _F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./node_modules/@dcloudio/vue-cli-plugin-uni/packages/vue-loader/lib/runtime/componentNormalizer.js */ 11); /* harmony import */ var _F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./node_modules/@dcloudio/vue-cli-plugin-uni/packages/vue-loader/lib/runtime/componentNormalizer.js */ 11);
var renderjs
/* normalize component */ /* normalize component */
// 使用 `componentNormalizer.js` 对 Vue 组件进行标准化处理，确保在不同平台上都能正确加载和执行该组件。
// `_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"]`
// 是 Webpack 通过 `import` 导入的 `componentNormalizer` 工具，它用于创建并标准化 Vue 组件。
// 参数顺序依次为：
// 1. 组件的脚本部分（逻辑代码）
// 2. 组件的渲染函数（模板渲染）
// 3. 组件的静态渲染函数（静态内容的渲染）
// 4. 是否启用热重载（这里传递 `false`，表示不开启）
// 5. 自定义的错误提示（这里传递 `null`，表示没有）
// 6. 特殊的生命周期钩子（这里传递 `null`，表示没有）
// 7. 动态组件的设置（这里传递 `null`，表示没有）
// 8. 是否进行渲染 JS（这里传递 `false`，表示没有）
// 9. 组件内部的嵌套组件（这里传递 `components`，表示引入的组件）
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], // 脚本部分，包含组件的业务逻辑 _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
_index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__["render"], // 渲染函数，负责生成 HTML 结构 _index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__["render"],
_index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], // 静态渲染函数，生成静态的 HTML 部分 _index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
false, // 禁用热重载（通常在开发过程中会启用热重载） false,
null, // 没有设置错误捕捉提示 null,
null, // 没有设置生命周期钩子 null,
null, // 没有特殊的动态组件设置 null,
false, // 没有渲染 JS false,
_index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__["components"], // 组件内嵌套的子组件 _index_vue_vue_type_template_id_7b78f232___WEBPACK_IMPORTED_MODULE_0__["components"],
renderjs // 渲染时需要的额外 JS 逻辑（可能是由某个特定的插件或者工具生成的额外 JS） renderjs
); )
// 给组件设置 `__file` 属性，标记该组件所在的文件路径。 component.options.__file = "components/uni-popup/index.vue"
// 这个文件路径是用于调试和错误跟踪的，在调试过程中，开发者可以通过这个属性查看该组件的源文件位置。
component.options.__file = "components/uni-popup/index.vue";
// 导出组件，允许其他模块导入和使用该组件。
// `component.exports` 将包含该组件的所有导出，通常会导出默认的 Vue 组件对象。
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);
/***/ }), /***/ }),
/***/ 188: /***/ 188:
@ -111,54 +70,21 @@ __webpack_require__.r(__webpack_exports__);
/*! exports provided: render, staticRenderFns, recyclableRender, components */ /*! exports provided: render, staticRenderFns, recyclableRender, components */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict"; // 严格模式，启用后可以帮助捕获一些潜在的错误，并且禁止某些不安全的操作 "use strict";
// __webpack_require__.r(__webpack_exports__);
// 这行代码用于标记当前模块是一个 ES6 模块。在 Webpack 中，模块通过这种方式进行标识，
// 以便其他模块能够正确地进行导入和导出。
__webpack_require__.r(__webpack_exports__); __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "render", function() { return render; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "render", function() { return render; });
// 使用 Webpack 的 `harmony export` 语法导出 `render` 函数，
// 使得 `render` 函数可以在其他模块中被访问和使用。
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
// 导出 `staticRenderFns`，它通常用于静态渲染函数，
// 这些函数用于渲染一些不依赖于数据变化的静态内容。
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
// 导出 `recyclableRender`，这是一个布尔值，用来标记组件的渲染是否支持回收机制，
// 通常在一些性能优化场景下，回收机制用于避免重复渲染同样的内容。
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
// 导出 `components`，它通常是一个包含组件列表的对象，用于标识该模块中所包含的子组件。 var components
// 在 Vue 组件中，这个字段用于定义组件的嵌套结构。
var components;
// 声明 `components` 变量，但并未赋值。
// 这个变量将在后续代码中包含具体的子组件。
var render = function() { var render = function() {
// `render` 函数是 Vue 组件的渲染函数，负责生成最终的 DOM 结构。 var _vm = this
var _vm = this; // `this` 指向 Vue 实例，包含该组件的数据和方法。 var _h = _vm.$createElement
var _h = _vm.$createElement; // `_h` 是 Vue 的 `createElement` 方法，用于创建虚拟 DOM 元素。 var _c = _vm._self._c || _h
var _c = _vm._self._c || _h; // 如果 `_self._c` 存在，使用它来创建元素，否则使用 `_h` 方法。
} }
var recyclableRender = false
var recyclableRender = false; var staticRenderFns = []
// `recyclableRender` 是一个标记，指示当前组件的渲染是否支持回收机制。 render._withStripped = true
// 如果为 `false`，表示不支持回收机制，通常为默认状态。
var staticRenderFns = [];
// `staticRenderFns` 是一个数组，存放静态渲染函数。
// 这些函数用于渲染不会变化的静态部分，一般用于优化性能。
// 这里为空数组，说明当前组件没有静态渲染函数。
render._withStripped = true;
// 这个标记告诉 Webpack 在编译过程中将会删除模板中的注释和空白部分，以优化输出。
// 这对减少最终打包文件的大小和提高性能有帮助。
@ -236,27 +162,12 @@ __webpack_require__.r(__webpack_exports__);
}]); }]);
//# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-popup/index.js.map //# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-popup/index.js.map
;(// 这行代码确保 `global["webpackJsonp"]` 是一个数组，如果它不存在则初始化为一个空数组。 ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
// Webpack 使用 `webpackJsonp` 来处理模块的异步加载和处理打包后的模块依赖。 'components/uni-popup/index-create-component',
global["webpackJsonp"] = global["webpackJsonp"] || []).push([
'components/uni-popup/index-create-component', // 这里定义了模块名称，在 `webpackJsonp` 数组中添加一个新的模块。
{ {
// 此对象描述了模块的加载和执行逻辑，键名 `'components/uni-popup/index-create-component'` 是模块的唯一标识。
'components/uni-popup/index-create-component':(function(module, exports, __webpack_require__){ 'components/uni-popup/index-create-component':(function(module, exports, __webpack_require__){
// 这是一个立即执行的函数表达式（IIFE），接收 `module`、`exports` 和 `__webpack_require__` 作为参数。 __webpack_require__('1')['createComponent'](__webpack_require__(187))
// `module` 和 `exports` 是 Node.js 中的模块机制的一部分，`__webpack_require__` 是 Webpack 提供的用于模块加载的函数。
// `__webpack_require__('1')` 加载模块编号为 `1` 的模块，并从中调用 `createComponent` 方法。
// 这个方法用于创建一个 Vue 组件，它的作用是通过 Webpack 的自动化工具将某个组件注册为一个可用的 Vue 组件。
__webpack_require__('1')['createComponent'](__webpack_require__(187));
// `__webpack_require__(187)` 加载并返回模块编号为 `187` 的模块（通常是 `uni-popup` 组件的实现文件）。
}) })
}, },
[ [['components/uni-popup/index-create-component']]
// 这是一个数组，定义了异步加载的模块依赖项，确保在加载 `'components/uni-popup/index-create-component'` 模块之前，
// 相关的依赖（`'components/uni-popup/index-create-component'`）会被正确地加载。
['components/uni-popup/index-create-component']
]
]); ]);

134
user/mp-weixin/components/uni-status-bar/uni-status-bar.js
Unescape View File

@ -7,38 +7,13 @@
/*! no static exports found */ /*! no static exports found */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict"; // 使用严格模式，确保代码的规范性和安全性 "use strict";
// 通过 `__webpack_require__.r()` 标记当前模块为 ES模块
__webpack_require__.r(__webpack_exports__); __webpack_require__.r(__webpack_exports__);
/* harmony import */ var _uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./uni-status-bar.vue?vue&type=template&id=86f9f2b8&scoped=true& */ 226);
/* harmony import */ /* harmony import */ var _uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./uni-status-bar.vue?vue&type=script&lang=js& */ 228);
// 导入 `uni-status-bar.vue` 模板部分，模板 ID 为 `86f9f2b8`，并且是 Scoped（局部作用域）的 /* harmony reexport (unknown) */ for(var __WEBPACK_IMPORT_KEY__ in _uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__) if(__WEBPACK_IMPORT_KEY__ !== 'default') (function(key) { __webpack_require__.d(__webpack_exports__, key, function() { return _uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__[key]; }) }(__WEBPACK_IMPORT_KEY__));
var _uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./uni-status-bar.vue?vue&type=template&id=86f9f2b8&scoped=true& */ 226); /* harmony import */ var _uni_status_bar_vue_vue_type_style_index_0_id_86f9f2b8_lang_scss_scoped_true___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./uni-status-bar.vue?vue&type=style&index=0&id=86f9f2b8&lang=scss&scoped=true& */ 230);
/* harmony import */ var _F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./node_modules/@dcloudio/vue-cli-plugin-uni/packages/vue-loader/lib/runtime/componentNormalizer.js */ 11);
/* harmony import */
// 导入 `uni-status-bar.vue` 的 JavaScript 逻辑部分，`lang=js` 表明是 JS 语言
var _uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./uni-status-bar.vue?vue&type=script&lang=js& */ 228);
// 使用 `harmony reexport` 将模块中的非 `default` 导出重新导出到当前模块的 `__webpack_exports__` 上
// 这样可以确保 `uni-status-bar.vue` 中的所有命名导出都能在外部被访问
/* harmony reexport (unknown) */
for(var __WEBPACK_IMPORT_KEY__ in _uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__)
if(__WEBPACK_IMPORT_KEY__ !== 'default')
(function(key) {
__webpack_require__.d(__webpack_exports__, key, function() {
return _uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__[key];
})
}(__WEBPACK_IMPORT_KEY__));
/* harmony import */
// 导入 `uni-status-bar.vue` 的样式部分，样式 ID 为 `86f9f2b8`，并且是 Scoped（局部作用域）的
var _uni_status_bar_vue_vue_type_style_index_0_id_86f9f2b8_lang_scss_scoped_true___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./uni-status-bar.vue?vue&type=style&index=0&id=86f9f2b8&lang=scss&scoped=true& */ 230);
/* harmony import */
// 导入 `vue-loader` 提供的 `componentNormalizer.js`，该文件用于标准化 Vue 组件的结构和生命周期钩子
// 主要用于兼容不同的 Vue 构建版本和插件
var _F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./node_modules/@dcloudio/vue-cli-plugin-uni/packages/vue-loader/lib/runtime/componentNormalizer.js */ 11);
var renderjs var renderjs
@ -48,46 +23,22 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 `componentNormalizer.js` 方法来标准化并初始化 Vue 组件
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
// 传入组件的脚本部分（默认导出的 JavaScript 逻辑）
_uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _uni_status_bar_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 传入组件的模板部分的渲染函数
_uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 传入组件的模板部分的静态渲染函数
_uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// `false` 表示该组件不是异步加载的
false, false,
// `null` 表示没有传入组件的上下文
null, null,
// `86f9f2b8` 是组件的作用域 ID，用于确保该组件的样式和 ID 是唯一的
"86f9f2b8", "86f9f2b8",
// `null` 表示没有额外的选项或处理
null, null,
// `false` 表示该组件不会使用 scoped 插槽
false, false,
// 传入组件中定义的子组件列表
_uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _uni_status_bar_vue_vue_type_template_id_86f9f2b8_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// `renderjs` 表示是否使用 JavaScript 渲染函数，通常用于一些特定的渲染场景
renderjs renderjs
); )
// 给组件设置 `__file` 属性，指明该组件对应的源文件路径
component.options.__file = "components/uni-status-bar/uni-status-bar.vue";
// 将标准化后的组件作为默认导出 component.options.__file = "components/uni-status-bar/uni-status-bar.vue"
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);
/***/ }), /***/ }),
/***/ 226: /***/ 226:
@ -126,36 +77,17 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
var components var components
// 定义组件的渲染函数
var render = function() { var render = function() {
// `this` 指向当前组件实例
var _vm = this var _vm = this
// `$createElement` 是 Vue 的内置方法，用于创建虚拟 DOM 元素
var _h = _vm.$createElement var _h = _vm.$createElement
// `_self._c` 是 Vue 的渲染函数，指向 `createElement`，用于生成虚拟 DOM。
// 如果 `_self._c` 不存在，则使用 `$createElement` 作为回退
var _c = _vm._self._c || _h var _c = _vm._self._c || _h
} }
// 标记 `recyclableRender` 为 `false`，表示渲染函数不可重用。
// 在某些 Vue 配置中，这可以用于优化性能。
// 该值通常在组件渲染时由 Vue 管理，默认为 `false`。
var recyclableRender = false var recyclableRender = false
// `staticRenderFns` 存放静态渲染函数的数组
// 该数组用于存放不依赖组件数据的静态内容，例如静态模板。
var staticRenderFns = [] var staticRenderFns = []
// `_withStripped` 属性通常用于标记渲染函数是否已经去除了字符串化代码。
// 这里设为 `true`，表示渲染函数中不再包含模板字符串。
// 这通常是为了性能优化或调试。
render._withStripped = true render._withStripped = true
/***/ }), /***/ }),
/***/ 228: /***/ 228:
@ -189,34 +121,15 @@ __webpack_require__.r(__webpack_exports__);
// //
// //
// 获取设备的系统信息，使用 `uni.getSystemInfoSync()` 同步方法获取 var statusBarHeight = uni.getSystemInfoSync().statusBarHeight + 'px';var _default =
// 该方法返回系统的各类信息，`statusBarHeight` 表示设备状态栏的高度（单位：px） {
// 将获取到的状态栏高度值转换为字符串并加上 'px' 单位
var statusBarHeight = uni.getSystemInfoSync().statusBarHeight + 'px';
// 默认导出的对象，包含一个 Vue 组件的基本结构
var _default = {
// 组件的名称为 'UniStatusBar'
name: 'UniStatusBar', name: 'UniStatusBar',
// data 函数定义了组件的响应式数据
data: function data() { data: function data() {
// 返回一个对象，其中包含一个响应式的 `statusBarHeight` 数据属性
// `statusBarHeight` 被初始化为之前获取到的状态栏高度（加上 'px' 单位）
return { return {
statusBarHeight: statusBarHeight statusBarHeight: statusBarHeight };
};
}
};
// 将组件对象导出为默认导出
exports.default = _default;
/* WEBPACK VAR INJECTION */ } };exports.default = _default;
// 这部分是 webpack 注入的代码，通常是为了兼容某些模块化的运行环境。 /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./node_modules/@dcloudio/uni-mp-weixin/dist/index.js */ 1)["default"]))
// 这里的 `__webpack_require__` 用于加载和执行与 UniApp 相关的模块，这一行并不会改变组件的功能。
// 它确保组件能够在 UniApp 环境下正常工作。
}.call(this, __webpack_require__(/*! ./node_modules/@dcloudio/uni-mp-weixin/dist/index.js */ 1)["default"]))
/***/ }), /***/ }),
@ -251,29 +164,12 @@ __webpack_require__.r(__webpack_exports__);
}]); }]);
//# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-status-bar/uni-status-bar.js.map //# sourceMappingURL=../../../.sourcemap/mp-weixin/components/uni-status-bar/uni-status-bar.js.map
;(// `global["webpackJsonp"]` 用于定义全局的 Webpack 扩展对象，这个对象主要用于处理模块的异步加载 ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
// 如果 `webpackJsonp` 尚未定义，则使用空数组 `[]` 作为默认值，确保不会覆盖已有的 `webpackJsonp` 对象
global["webpackJsonp"] = global["webpackJsonp"] || []).push([
// 第一个参数是一个标识符数组，这里是一个字符串，用来标识该模块在打包时的名称
// 'components/uni-status-bar/uni-status-bar-create-component' 是这个模块的标识符
'components/uni-status-bar/uni-status-bar-create-component', 'components/uni-status-bar/uni-status-bar-create-component',
// 第二个参数是一个对象，定义了当前模块的实际内容
{ {
// 模块 'components/uni-status-bar/uni-status-bar-create-component' 的实现
// 这个对象的键名对应着模块的名称，值是一个函数，负责定义该模块的逻辑
'components/uni-status-bar/uni-status-bar-create-component':(function(module, exports, __webpack_require__){ 'components/uni-status-bar/uni-status-bar-create-component':(function(module, exports, __webpack_require__){
// 通过 `__webpack_require__` 动态引入并执行模块，`__webpack_require__` 是 Webpack 的一个内置函数 __webpack_require__('1')['createComponent'](__webpack_require__(225))
// `__webpack_require__('1')` 引入模块 1，这个模块通常是 UniApp 的核心模块，包含了一些通用的 API 和方法
// `createComponent` 方法用于创建一个组件，通常是将 Vue 组件注册到框架中以便使用
// `__webpack_require__(225)` 引入 `225` 模块，这通常是指组件的实现代码（即 `uni-status-bar` 组件的代码）
__webpack_require__('1')['createComponent'](__webpack_require__(225));
}) })
}, },
// 第三个参数是一个数组，通常是指定依赖的模块名称
// 在这里指定了模块 'components/uni-status-bar/uni-status-bar-create-component' 作为依赖
[['components/uni-status-bar/uni-status-bar-create-component']] [['components/uni-status-bar/uni-status-bar-create-component']]
]); ]);

106
user/mp-weixin/node-modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput.js
Unescape View File

@ -23,25 +23,19 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 Vue 的组件规范化工具对组件进行标准化处理
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
// 引入组件的脚本部分
_uni_easyinput_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _uni_easyinput_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 引入组件的模板部分
_uni_easyinput_vue_vue_type_template_id_20076044___WEBPACK_IMPORTED_MODULE_0__["render"], _uni_easyinput_vue_vue_type_template_id_20076044___WEBPACK_IMPORTED_MODULE_0__["render"],
// 引入组件的静态渲染函数
_uni_easyinput_vue_vue_type_template_id_20076044___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _uni_easyinput_vue_vue_type_template_id_20076044___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
false, // 是否在编译时将组件渲染为纯 HTML，这里设置为 false false,
null, // 没有父组件 null,
null, // 没有模块上下文 null,
null, // 没有 Ctor 函数 null,
false, // 不强制要求组件具有渲染函数 false,
// 引入组件的子组件
_uni_easyinput_vue_vue_type_template_id_20076044___WEBPACK_IMPORTED_MODULE_0__["components"], _uni_easyinput_vue_vue_type_template_id_20076044___WEBPACK_IMPORTED_MODULE_0__["components"],
renderjs // 额外的渲染选项 renderjs
) )
component.options.__file = "node_modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput.vue" component.options.__file = "node_modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput.vue"
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);
@ -82,24 +76,18 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
// 定义一个变量 components，用于存储组件的引用
var components var components
try { try {
// 尝试动态加载 uni-icons 组件
components = { components = {
uniIcons: function() { uniIcons: function() {
return Promise.all(/*! import() | components/uni-icons/uni-icons */[__webpack_require__.e("common/vendor"), __webpack_require__.e("components/uni-icons/uni-icons")]).then(__webpack_require__.bind(null, /*! @/components/uni-icons/uni-icons.vue */ 232)) return Promise.all(/*! import() | components/uni-icons/uni-icons */[__webpack_require__.e("common/vendor"), __webpack_require__.e("components/uni-icons/uni-icons")]).then(__webpack_require__.bind(null, /*! @/components/uni-icons/uni-icons.vue */ 232))
} }
} }
} catch (e) { } catch (e) {
// 如果加载过程中出现错误，检查错误信息是否与找不到模块有关
if ( if (
e.message.indexOf("Cannot find module") !== -1 && e.message.indexOf("Cannot find module") !== -1 &&
e.message.indexOf(".vue") !== -1 e.message.indexOf(".vue") !== -1
) { ) {
// 输出错误信息和排查建议
console.error(e.message) console.error(e.message)
console.error("1. 排查组件名称拼写是否正确") console.error("1. 排查组件名称拼写是否正确")
console.error( console.error(
@ -109,24 +97,16 @@ __webpack_require__.r(__webpack_exports__);
"3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件" "3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件"
) )
} else { } else {
// 如果错误不是由于找不到模块引起的，则重新抛出错误
throw e throw e
} }
} }
var render = function() { var render = function() {
// 获取当前Vue实例的引用
var _vm = this var _vm = this
// 创建一个虚拟节点创建函数，用于生成VNode
var _h = _vm.$createElement var _h = _vm.$createElement
// 定义一个渲染函数，如果存在自定义的渲染函数则使用它，否则使用默认的虚拟节点创建函数
var _c = _vm._self._c || _h var _c = _vm._self._c || _h
} }
// 标记是否可回收渲染函数
var recyclableRender = false var recyclableRender = false
// 静态渲染函数数组，通常用于不依赖组件状态的静态内容
var staticRenderFns = [] var staticRenderFns = []
// 标记渲染函数已被剥离（即移除了生产环境的警告信息）
render._withStripped = true render._withStripped = true
@ -237,95 +217,97 @@ Object.defineProperty(exports, "__esModule", { value: true });exports.default =
*/var _default2 = */var _default2 =
{ {
name: 'uni-easyinput', // 组件名称 name: 'uni-easyinput',
emits: ['click', 'iconClick', 'update:modelValue', 'input', 'focus', 'blur', 'confirm'], // 定义组件可以触发的事件 emits: ['click', 'iconClick', 'update:modelValue', 'input', 'focus', 'blur', 'confirm'],
model: { model: {
prop: 'modelValue', // 绑定的prop属性名 prop: 'modelValue',
event: 'update:modelValue' }, // 更新prop时触发的事件 event: 'update:modelValue' },
props: { props: {
name: String, // 输入框的名称 name: String,
value: [Number, String], // 输入框的值，可以是数字或字符串 value: [Number, String],
modelValue: [Number, String], // 双向绑定的值，可以是数字或字符串 modelValue: [Number, String],
type: { type: {
type: String, type: String,
default: 'text' }, // 输入框的类型，默认是文本类型 default: 'text' },
clearable: { clearable: {
type: Boolean, type: Boolean,
default: true }, // 是否显示清除按钮，默认显示 default: true },
autoHeight: { autoHeight: {
type: Boolean, type: Boolean,
default: false }, // 是否自动调整高度，默认不自动调整 default: false },
placeholder: String, // 占位符文本 placeholder: String,
placeholderStyle: String, // 占位符样式 placeholderStyle: String,
focus: { focus: {
type: Boolean, type: Boolean,
default: false }, // 是否自动获取焦点，默认不自动获取焦点 default: false },
disabled: { disabled: {
type: Boolean, type: Boolean,
default: false }, // 是否禁用输入框，默认不禁用 default: false },
maxlength: { maxlength: {
type: [Number, String], type: [Number, String],
default: 140 }, // 输入框的最大长度，默认140 default: 140 },
confirmType: { confirmType: {
type: String, type: String,
default: 'done' }, // 确认按钮的类型，默认是“完成” default: 'done' },
clearSize: { clearSize: {
type: [Number, String], type: [Number, String],
default: 15 }, // 清除按钮的大小，默认15 default: 15 },
inputBorder: { inputBorder: {
type: Boolean, type: Boolean,
default: true }, // 是否显示输入框边框，默认显示 default: true },
prefixIcon: { prefixIcon: {
type: String, type: String,
default: '' }, // 前缀图标 default: '' },
suffixIcon: { suffixIcon: {
type: String, type: String,
default: '' }, // 后缀图标 default: '' },
trim: { trim: {
type: [Boolean, String], type: [Boolean, String],
default: true }, // 是否去除前后空格，默认去除 default: true },
passwordIcon: { passwordIcon: {
type: Boolean, type: Boolean,
default: true }, // 是否显示密码切换图标，默认显示 default: true },
styles: { styles: {
type: Object, type: Object,
default: function _default() { default: function _default() {
return { return {
color: '#333', // 默认文字颜色 color: '#333',
disableColor: '#F7F6F6', // 禁用状态下的文字颜色 disableColor: '#F7F6F6',
borderColor: '#e5e5e5' }; // 边框颜色 borderColor: '#e5e5e5' };
} }, } },
errorMessage: { errorMessage: {
type: [String, Boolean], type: [String, Boolean],
default: '' } }, // 错误信息，可以是字符串或布尔值，默认为空字符串 default: '' } },
data: function data() { data: function data() {
return { return {
focused: false, // 是否聚焦状态 focused: false,
errMsg: '', // 错误信息 errMsg: '',
val: '', // 当前输入的值 val: '',
showMsg: '', // 显示的信息 showMsg: '',
border: false, // 是否有边框 border: false,
isFirstBorder: false, // 是否是第一个边框 isFirstBorder: false,
showClearIcon: false, // 是否显示清除图标 showClearIcon: false,
showPassword: false }; // 是否显示密码图标 showPassword: false };
}
, },
computed: { computed: {
msg: function msg() { msg: function msg() {
return this.errorMessage || this.errMsg; return this.errorMessage || this.errMsg;

31
user/mp-weixin/node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item.js
Unescape View File

@ -76,21 +76,17 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
var components // 定义一个变量来存储组件对象 var components
try { try {
// 尝试动态加载组件
components = { components = {
uniIcons: function() { uniIcons: function() {
// 使用 Promise.all 并行加载多个模块，然后返回 uni-icons 组件
return Promise.all(/*! import() | components/uni-icons/uni-icons */[__webpack_require__.e("common/vendor"), __webpack_require__.e("components/uni-icons/uni-icons")]).then(__webpack_require__.bind(null, /*! @/components/uni-icons/uni-icons.vue */ 232)) return Promise.all(/*! import() | components/uni-icons/uni-icons */[__webpack_require__.e("common/vendor"), __webpack_require__.e("components/uni-icons/uni-icons")]).then(__webpack_require__.bind(null, /*! @/components/uni-icons/uni-icons.vue */ 232))
}, },
uniBadge: function() { uniBadge: function() {
// 动态加载 uni-badge 组件
return __webpack_require__.e(/*! import() | uni_modules/uni-badge/components/uni-badge/uni-badge */ "uni_modules/uni-badge/components/uni-badge/uni-badge").then(__webpack_require__.bind(null, /*! @/uni_modules/uni-badge/components/uni-badge/uni-badge.vue */ 240)) return __webpack_require__.e(/*! import() | uni_modules/uni-badge/components/uni-badge/uni-badge */ "uni_modules/uni-badge/components/uni-badge/uni-badge").then(__webpack_require__.bind(null, /*! @/uni_modules/uni-badge/components/uni-badge/uni-badge.vue */ 240))
} }
} }
} catch (e) { } catch (e) {
// 如果加载组件失败，检查错误信息并给出排查建议
if ( if (
e.message.indexOf("Cannot find module") !== -1 && e.message.indexOf("Cannot find module") !== -1 &&
e.message.indexOf(".vue") !== -1 e.message.indexOf(".vue") !== -1
@ -104,21 +100,17 @@ __webpack_require__.r(__webpack_exports__);
"3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件" "3. 若组件不符合 easycom 规范，需手动引入，并在 components 中注册该组件"
) )
} else { } else {
throw e // 如果错误不是找不到模块，则重新抛出错误 throw e
} }
} }
// 渲染函数，用于生成页面的 HTML 结构
var render = function() { var render = function() {
var _vm = this // 获取当前实例 var _vm = this
var _h = _vm.$createElement // 创建虚拟节点的方法 var _h = _vm.$createElement
var _c = _vm._self._c || _h // 渲染函数的辅助方法 var _c = _vm._self._c || _h
} }
var recyclableRender = false
var recyclableRender = false // 标记是否可回收渲染 var staticRenderFns = []
var staticRenderFns = [] // 静态渲染函数数组，通常用于优化性能 render._withStripped = true
render._withStripped = true // 标记渲染函数为已剥离（去除调试信息）
@ -444,14 +436,11 @@ __webpack_require__.r(__webpack_exports__);
}]); }]);
//# sourceMappingURL=../../../../../../.sourcemap/mp-weixin/node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item.js.map //# sourceMappingURL=../../../../../../.sourcemap/mp-weixin/node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item.js.map
;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([ ;(global["webpackJsonp"] = global["webpackJsonp"] || []).push([
'node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item-create-component', // 模块路径 'node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item-create-component',
{ {
// 定义模块内容
'node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item-create-component':(function(module, exports, __webpack_require__){ 'node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item-create-component':(function(module, exports, __webpack_require__){
// 使用 createComponent 方法创建组件，传入的参数是 uni-list-item 组件的定义
__webpack_require__('1')['createComponent'](__webpack_require__(173)) __webpack_require__('1')['createComponent'](__webpack_require__(173))
}) })
}, },
[['node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item-create-component']] // 依赖项数组 [['node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item-create-component']]
]); ]);

17
user/mp-weixin/pages/addOrEditAddress/addOrEditAddress.js
Unescape View File

@ -1,6 +1,9 @@
(global["webpackJsonp"] = global["webpackJsonp"] || []).push([["pages/addOrEditAddress/addOrEditAddress"],{ (global["webpackJsonp"] = global["webpackJsonp"] || []).push([["pages/addOrEditAddress/addOrEditAddress"],{
/***/ 115: /***/ 115:
/*!************************************************************************************************************!*\
!*** D:/project/project-rjwm-weixin-uniapp/main.js?{"page":"pages%2FaddOrEditAddress%2FaddOrEditAddress"} ***!
\************************************************************************************************************/
/*! no static exports found */ /*! no static exports found */
/***/ (function(module, exports, __webpack_require__) { /***/ (function(module, exports, __webpack_require__) {
@ -57,6 +60,9 @@ component.options.__file = "pages/addOrEditAddress/addOrEditAddress.vue"
/***/ }), /***/ }),
/***/ 117: /***/ 117:
/*!************************************************************************************************************************************!*\
!*** D:/project/project-rjwm-weixin-uniapp/pages/addOrEditAddress/addOrEditAddress.vue?vue&type=template&id=174d7646&scoped=true& ***!
\************************************************************************************************************************************/
/*! exports provided: render, staticRenderFns, recyclableRender, components */ /*! exports provided: render, staticRenderFns, recyclableRender, components */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
@ -76,6 +82,9 @@ __webpack_require__.r(__webpack_exports__);
/***/ }), /***/ }),
/***/ 118: /***/ 118:
/*!************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
!*** ./node_modules/@dcloudio/vue-cli-plugin-uni/packages/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/@dcloudio/vue-cli-plugin-uni/packages/webpack-preprocess-loader??ref--16-0!./node_modules/@dcloudio/webpack-uni-mp-loader/lib/template.js!./node_modules/@dcloudio/vue-cli-plugin-uni/packages/webpack-uni-app-loader/page-meta.js!./node_modules/@dcloudio/vue-cli-plugin-uni/packages/vue-loader/lib??vue-loader-options!./node_modules/@dcloudio/webpack-uni-mp-loader/lib/style.js!D:/project/project-rjwm-weixin-uniapp/pages/addOrEditAddress/addOrEditAddress.vue?vue&type=template&id=174d7646&scoped=true& ***!
\************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
/*! exports provided: render, staticRenderFns, recyclableRender, components */ /*! exports provided: render, staticRenderFns, recyclableRender, components */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
@ -126,6 +135,10 @@ render._withStripped = true
/***/ }), /***/ }),
/***/ 119: /***/ 119:
/*!******************************************************************************************************************!*\
!*** D:/project/project-rjwm-weixin-uniapp/pages/addOrEditAddress/addOrEditAddress.vue?vue&type=script&lang=js& ***!
\******************************************************************************************************************/
/*! no static exports found */
/***/ (function(module, __webpack_exports__, __webpack_require__) { /***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict"; "use strict";
@ -138,6 +151,10 @@ __webpack_require__.r(__webpack_exports__);
/***/ }), /***/ }),
/***/ 120: /***/ 120:
/*!*************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
!*** ./node_modules/babel-loader/lib!./node_modules/@dcloudio/vue-cli-plugin-uni/packages/webpack-preprocess-loader??ref--12-1!./node_modules/@dcloudio/webpack-uni-mp-loader/lib/script.js!./node_modules/@dcloudio/vue-cli-plugin-uni/packages/vue-loader/lib??vue-loader-options!./node_modules/@dcloudio/webpack-uni-mp-loader/lib/style.js!D:/project/project-rjwm-weixin-uniapp/pages/addOrEditAddress/addOrEditAddress.vue?vue&type=script&lang=js& ***!
\*************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) { /***/ (function(module, exports, __webpack_require__) {
"use strict"; "use strict";

17
user/mp-weixin/pages/details/index.js
Unescape View File

@ -96,11 +96,8 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "staticRenderFns", function() { return staticRenderFns; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recyclableRender", function() { return recyclableRender; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "components", function() { return components; });
// 定义组件对象，用于动态加载组件
var components var components
try { try {
// 尝试加载 uniNavBar 和 uniPopup 组件
components = { components = {
uniNavBar: function() { uniNavBar: function() {
return __webpack_require__.e(/*! import() | components/uni-nav-bar/uni-nav-bar */ "components/uni-nav-bar/uni-nav-bar").then(__webpack_require__.bind(null, /*! @/components/uni-nav-bar/uni-nav-bar.vue */ 145)) return __webpack_require__.e(/*! import() | components/uni-nav-bar/uni-nav-bar */ "components/uni-nav-bar/uni-nav-bar").then(__webpack_require__.bind(null, /*! @/components/uni-nav-bar/uni-nav-bar.vue */ 145))
@ -110,7 +107,6 @@ __webpack_require__.r(__webpack_exports__);
} }
} }
} catch (e) { } catch (e) {
// 如果加载组件失败，检查错误信息并给出排查建议
if ( if (
e.message.indexOf("Cannot find module") !== -1 && e.message.indexOf("Cannot find module") !== -1 &&
e.message.indexOf(".vue") !== -1 e.message.indexOf(".vue") !== -1
@ -127,19 +123,15 @@ __webpack_require__.r(__webpack_exports__);
throw e throw e
} }
} }
// 渲染函数，用于生成页面的 HTML 结构
var render = function() { var render = function() {
var _vm = this var _vm = this
var _h = _vm.$createElement var _h = _vm.$createElement
var _c = _vm._self._c || _h var _c = _vm._self._c || _h
// 获取订单状态的描述文字
var m0 = _vm.statusWord(_vm.orderDetailsData.status) var m0 = _vm.statusWord(_vm.orderDetailsData.status)
// 遍历订单数据，格式化金额
var l0 = _vm.__map(_vm.orderDataes, function(obj, index) { var l0 = _vm.__map(_vm.orderDataes, function(obj, index) {
var $orig = _vm.__get_orig(obj) var $orig = _vm.__get_orig(obj)
var g0 = obj.amount.toFixed(2) var g0 = obj.amount.toFixed(2)
return { return {
$orig: $orig, $orig: $orig,
@ -147,14 +139,12 @@ __webpack_require__.r(__webpack_exports__);
} }
}) })
// 如果组件未挂载，则绑定点击事件处理函数
if (!_vm._isMounted) { if (!_vm._isMounted) {
_vm.e0 = function($event) { _vm.e0 = function($event) {
_vm.showDisplay = !_vm.showDisplay _vm.showDisplay = !_vm.showDisplay
} }
} }
// 将数据绑定到模板中
_vm.$mp.data = Object.assign( _vm.$mp.data = Object.assign(
{}, {},
{ {
@ -165,17 +155,12 @@ __webpack_require__.r(__webpack_exports__);
} }
) )
} }
// 标记是否可回收渲染
var recyclableRender = false var recyclableRender = false
// 静态渲染函数数组，通常用于优化性能
var staticRenderFns = [] var staticRenderFns = []
// 标记渲染函数为已剥离（去除调试信息）
render._withStripped = true render._withStripped = true
/***/ }) /***/ })
},[[46,"common/runtime","common/vendor"]]]); },[[46,"common/runtime","common/vendor"]]]);

12
user/mp-weixin/pages/nonet/index.js
Unescape View File

@ -43,31 +43,19 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 Vue 的组件规范化工具来创建一个 Vue 组件实例
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])(
// 引入组件的类型脚本模块，这里通常是定义组件逻辑和数据的部分
_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 引入组件的模板渲染函数，用于描述组件的 HTML 结构
_index_vue_vue_type_template_id_751e51d6_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _index_vue_vue_type_template_id_751e51d6_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 引入组件的静态渲染函数数组，用于优化渲染性能
_index_vue_vue_type_template_id_751e51d6_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _index_vue_vue_type_template_id_751e51d6_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 是否为 functional 组件，false 表示这是一个普通的 Vue 组件
false, false,
// 父组件的构造函数，通常在继承时使用
null, null,
// 组件的唯一标识符，用于调试和缓存
"751e51d6", "751e51d6",
// 父组件的上下文对象，通常在继承时使用
null, null,
// 是否为纯组件，true 表示该组件不会响应数据变化
false, false,
// 注册的子组件列表，用于在父组件中引用子组件
_index_vue_vue_type_template_id_751e51d6_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _index_vue_vue_type_template_id_751e51d6_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// renderjs 是一个可选参数，用于指定是否启用 renderjs 功能
renderjs renderjs
) )
component.options.__file = "pages/nonet/index.vue" component.options.__file = "pages/nonet/index.vue"
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);

11
user/mp-weixin/pages/order/index.js
Unescape View File

@ -45,27 +45,16 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 Vue 的组件规范化工具来创建一个 Vue 组件实例
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_5__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_5__["default"])(
// 引入组件的类型脚本模块，这里通常是定义组件逻辑和数据的部分
_index_js_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _index_js_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 引入组件的模板渲染函数，用于描述组件的 HTML 结构
_index_vue_vue_type_template_id_0ca91b30_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _index_vue_vue_type_template_id_0ca91b30_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 引入组件的静态渲染函数数组，用于优化渲染性能
_index_vue_vue_type_template_id_0ca91b30_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _index_vue_vue_type_template_id_0ca91b30_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 是否为 functional 组件，false 表示这是一个普通的 Vue 组件
false, false,
// 父组件的构造函数，通常在继承时使用
null, null,
// 组件的唯一标识符，用于调试和缓存
"0ca91b30", "0ca91b30",
// 父组件的上下文对象，通常在继承时使用
null, null,
// 是否为纯组件，true 表示该组件不会响应数据变化
false, false,
// 注册的子组件列表，用于在父组件中引用子组件
_index_vue_vue_type_template_id_0ca91b30_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _index_vue_vue_type_template_id_0ca91b30_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// renderjs 是一个可选参数，用于指定是否启用 renderjs 功能
renderjs renderjs
) )

12
user/mp-weixin/pages/pay/index.js
Unescape View File

@ -43,31 +43,19 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 Vue 的组件规范化工具来创建一个 Vue 组件实例
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])(
// 引入组件的类型脚本模块，这里通常是定义组件逻辑和数据的部分
_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 引入组件的模板渲染函数，用于描述组件的 HTML 结构
_index_vue_vue_type_template_id_32f2f1fc_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _index_vue_vue_type_template_id_32f2f1fc_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 引入组件的静态渲染函数数组，用于优化渲染性能
_index_vue_vue_type_template_id_32f2f1fc_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _index_vue_vue_type_template_id_32f2f1fc_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 是否为 functional 组件，false 表示这是一个普通的 Vue 组件
false, false,
// 父组件的构造函数，通常在继承时使用
null, null,
// 组件的唯一标识符，用于调试和缓存
"32f2f1fc", "32f2f1fc",
// 父组件的上下文对象，通常在继承时使用
null, null,
// 是否为纯组件，true 表示该组件不会响应数据变化
false, false,
// 注册的子组件列表，用于在父组件中引用子组件
_index_vue_vue_type_template_id_32f2f1fc_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _index_vue_vue_type_template_id_32f2f1fc_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// renderjs 是一个可选参数，用于指定是否启用 renderjs 功能
renderjs renderjs
) )
component.options.__file = "pages/pay/index.vue" component.options.__file = "pages/pay/index.vue"
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);

12
user/mp-weixin/pages/remark/index.js
Unescape View File

@ -25,31 +25,19 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 Vue 的组件规范化工具来创建一个 Vue 组件实例
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])(
// 引入组件的类型脚本模块，这里通常是定义组件逻辑和数据的部分
_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 引入组件的模板渲染函数，用于描述组件的 HTML 结构
_index_vue_vue_type_template_id_27c0a608_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _index_vue_vue_type_template_id_27c0a608_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 引入组件的静态渲染函数数组，用于优化渲染性能
_index_vue_vue_type_template_id_27c0a608_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _index_vue_vue_type_template_id_27c0a608_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 是否为 functional 组件，false 表示这是一个普通的 Vue 组件
false, false,
// 父组件的构造函数，通常在继承时使用
null, null,
// 组件的唯一标识符，用于调试和缓存
"27c0a608", "27c0a608",
// 父组件的上下文对象，通常在继承时使用
null, null,
// 是否为纯组件，true 表示该组件不会响应数据变化
false, false,
// 注册的子组件列表，用于在父组件中引用子组件
_index_vue_vue_type_template_id_27c0a608_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _index_vue_vue_type_template_id_27c0a608_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// renderjs 是一个可选参数，用于指定是否启用 renderjs 功能
renderjs renderjs
) )
component.options.__file = "pages/remark/index.vue" component.options.__file = "pages/remark/index.vue"
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);

12
user/mp-weixin/pages/success/index.js
Unescape View File

@ -43,31 +43,19 @@ var renderjs
/* normalize component */ /* normalize component */
// 使用 Vue 的组件规范化工具来创建一个 Vue 组件实例
var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])( var component = Object(_F_HBuilderX_2_2_2_20190816_HBuilderX_plugins_uniapp_cli_node_modules_dcloudio_vue_cli_plugin_uni_packages_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_4__["default"])(
// 引入组件的类型脚本模块，这里通常是定义组件逻辑和数据的部分
_index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"], _index_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__["default"],
// 引入组件的模板渲染函数，用于描述组件的 HTML 结构
_index_vue_vue_type_template_id_6fde291d_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"], _index_vue_vue_type_template_id_6fde291d_scoped_true___WEBPACK_IMPORTED_MODULE_0__["render"],
// 引入组件的静态渲染函数数组，用于优化渲染性能
_index_vue_vue_type_template_id_6fde291d_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"], _index_vue_vue_type_template_id_6fde291d_scoped_true___WEBPACK_IMPORTED_MODULE_0__["staticRenderFns"],
// 是否为 functional 组件，false 表示这是一个普通的 Vue 组件
false, false,
// 父组件的构造函数，通常在继承时使用
null, null,
// 组件的唯一标识符，用于调试和缓存
"6fde291d", "6fde291d",
// 父组件的上下文对象，通常在继承时使用
null, null,
// 是否为纯组件，true 表示该组件不会响应数据变化
false, false,
// 注册的子组件列表，用于在父组件中引用子组件
_index_vue_vue_type_template_id_6fde291d_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"], _index_vue_vue_type_template_id_6fde291d_scoped_true___WEBPACK_IMPORTED_MODULE_0__["components"],
// renderjs 是一个可选参数，用于指定是否启用 renderjs 功能
renderjs renderjs
) )
component.options.__file = "pages/success/index.vue" component.options.__file = "pages/success/index.vue"
/* harmony default export */ __webpack_exports__["default"] = (component.exports); /* harmony default export */ __webpack_exports__["default"] = (component.exports);

Write Preview
Loading…
Cancel
Save