qiuhongwu 1 year ago
commit e95a62ae5c

@ -144,11 +144,11 @@ public class BusinessWarehouseController {
@Operation(summary = "获得业务线详情")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:detail')")
public CommonResult<BusinessDetail> getBusinessWarehouse(@RequestParam("id") Long id, BusinessUserVO reqVO) {
public CommonResult<BusinessDetail> getBusinessWarehouse(@Valid BusinessUserVO reqVO) {
BusinessDetail businessDetail = new BusinessDetail();
BusinessWarehouseDO businessWarehouse = businessWarehouseService.getBusinessWarehouse(id);
BusinessWarehouseDO businessWarehouse = businessWarehouseService.getBusinessWarehouse(reqVO.getId());
businessDetail.setBusinessWarehouseInfo(businessWarehouse);
List<EnterpriseBranchDO> enterpriseBranchDOList = businessWarehouseService.queryEnterpriseInfo(id);
List<EnterpriseBranchDO> enterpriseBranchDOList = businessWarehouseService.queryEnterpriseInfo(reqVO.getId());
businessDetail.setEnterpriseBranchList(enterpriseBranchDOList);
PageResult<BusinessUserVO> pageResult = businessWarehouseService.getBusinessUserList(reqVO);
businessDetail.setBusinessUserList(pageResult);

@ -92,6 +92,10 @@ public interface ErrorCodeConstants {
ErrorCode PRODUCT_MODIFICATION_NOT_EXISTS = new ErrorCode(1003004029, "批量修改单不存在");
ErrorCode PRODUCT_BOM_NOT_EXISTS = new ErrorCode(1003004030, "商品BOM管理不存在");
ErrorCode PRODUCT_LNVENTORY_UNIT_NOT_EXISTS = new ErrorCode(1003004031, "商品表库存单位不存在");
ErrorCode PRODUCT_MODIFICATION_ITEM0_NOT_EXISTS = new ErrorCode(1003004032, "批量修改单商品不存在");
ErrorCode PRODUCT_PARAMETER_VALUE_NOT_EXISTS = new ErrorCode(1003004033, "商品参数值不存在");
ErrorCode PRODUCT_BUSINESS_NOT_EXISTS = new ErrorCode(1003004034, "商品表和业务线关联关系不存在");
ErrorCode PRODUCT_LABEL_ID_NOT_EXISTS = new ErrorCode(1003004035, "商品标签关联关系不存在");
/**
* 使 1-005-000-000
*/
@ -99,10 +103,17 @@ public interface ErrorCodeConstants {
// ========== 合同信息 500100001 ==========
ErrorCode CONTRACT_NOT_EXISTS = new ErrorCode(1005000001, "合同信息不存在");
// ========== 合同详情信息 500100001 ==========
ErrorCode CONTRACT_INFO_NOT_EXISTS = new ErrorCode(1005000002, "合同详情信息不存在");
// ========== 合同条款 TODO 补充编号 ==========
ErrorCode CONTRACT_CLAUSE_NOT_EXISTS = new ErrorCode(1005000012, "合同条款不存在");
// ========== 合同模板 TODO 补充编号 ==========
ErrorCode CONTRACT_TEMPLATE_NOT_EXISTS = new ErrorCode(1005000013, "合同模板不存在");
// ========== 主体负责人转移 TODO 补充编号 ==========
ErrorCode SUBJECT_TRANSFER_NOT_EXISTS = new ErrorCode(1005000003, "主体负责人转移不存在");
@ -113,4 +124,6 @@ public interface ErrorCodeConstants {
ErrorCode SUBJECT_CONTACTS_NOT_EXISTS = new ErrorCode(1005000005, "主体联系人不存在");
// ========== 主体代表人 TODO 补充编号 ==========
ErrorCode SUBJECT_REPRESENTATIVE_NOT_EXISTS = new ErrorCode(1005000006, "主体代表人不存在");
// ========== 主体业务线 TODO 补充编号 ==========
ErrorCode SUBJECT_BUSINESS_NOT_EXISTS = new ErrorCode(1005000007, "主体业务线不存在");
}

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import com.yunxi.scm.module.xxjj.convert.contractclause.ContractClauseConvert;
import com.yunxi.scm.module.xxjj.service.contractclause.ContractClauseService;
@Tag(name = "管理后台 - 合同条款")
@RestController
@RequestMapping("/xxjj/contract-clause")
@Validated
public class ContractClauseController {
@Resource
private ContractClauseService contractClauseService;
@PostMapping("/create")
@Operation(summary = "创建合同条款")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:create')")
public CommonResult<Long> createContractClause(@Valid @RequestBody ContractClauseCreateReqVO createReqVO) {
return success(contractClauseService.createContractClause(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新合同条款")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:update')")
public CommonResult<Boolean> updateContractClause(@Valid @RequestBody ContractClauseUpdateReqVO updateReqVO) {
contractClauseService.updateContractClause(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除合同条款")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:delete')")
public CommonResult<Boolean> deleteContractClause(@RequestParam("id") Long id) {
contractClauseService.deleteContractClause(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得合同条款")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:query')")
public CommonResult<ContractClauseRespVO> getContractClause(@RequestParam("id") Long id) {
ContractClauseDO contractClause = contractClauseService.getContractClause(id);
return success(ContractClauseConvert.INSTANCE.convert(contractClause));
}
@GetMapping("/list")
@Operation(summary = "获得合同条款列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:query')")
public CommonResult<List<ContractClauseRespVO>> getContractClauseList(@RequestParam("ids") Collection<Long> ids) {
List<ContractClauseDO> list = contractClauseService.getContractClauseList(ids);
return success(ContractClauseConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得合同条款分页")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:query')")
public CommonResult<PageResult<ContractClauseRespVO>> getContractClausePage(@Valid ContractClausePageReqVO pageVO) {
PageResult<ContractClauseDO> pageResult = contractClauseService.getContractClausePage(pageVO);
return success(ContractClauseConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出合同条款 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:export')")
@OperateLog(type = EXPORT)
public void exportContractClauseExcel(@Valid ContractClauseExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ContractClauseDO> list = contractClauseService.getContractClauseList(exportReqVO);
// 导出 Excel
List<ContractClauseExcelVO> datas = ContractClauseConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "合同条款.xls", "数据", ContractClauseExcelVO.class, datas);
}
}

@ -0,0 +1,42 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class ContractClauseBaseVO {
@Schema(description = "条款标题", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "条款标题不能为空")
private String title;
@Schema(description = "条款类型 参考字典contract_clause_type", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "条款类型 参考字典contract_clause_type不能为空")
private String type;
@Schema(description = "状态 参考字典contract_clause_status", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
@NotNull(message = "状态 参考字典contract_clause_status不能为空")
private String status;
@Schema(description = "条款内容", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "条款内容不能为空")
private String content;
@Schema(description = "权重值")
private Short weight;
@Schema(description = "备注", example = "随便")
private String remark;
@Schema(description = "附件")
private String attachment;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同条款创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClauseCreateReqVO extends ContractClauseBaseVO {
}

@ -0,0 +1,51 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
/**
* Excel VO
*
* @author
*/
@Data
public class ContractClauseExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("条款标题")
private String title;
@ExcelProperty(value = "条款类型 参考字典contract_clause_type", converter = DictConvert.class)
@DictFormat("contract_clause_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String type;
@ExcelProperty(value = "状态 参考字典contract_clause_status", converter = DictConvert.class)
@DictFormat("contract_clause_status") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String status;
@ExcelProperty("条款内容")
private String content;
@ExcelProperty("权重值")
private Short weight;
@ExcelProperty("备注")
private String remark;
@ExcelProperty("附件")
private String attachment;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,29 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同条款 Excel 导出 Request VO参数和 ContractClausePageReqVO 是一致的")
@Data
public class ContractClauseExportReqVO {
@Schema(description = "条款标题")
private String title;
@Schema(description = "条款类型 参考字典contract_clause_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_clause_status", example = "2")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同条款分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClausePageReqVO extends PageParam {
@Schema(description = "条款标题")
private String title;
@Schema(description = "条款类型 参考字典contract_clause_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_clause_status", example = "2")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 合同条款 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClauseRespVO extends ContractClauseBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "7146")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同条款更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClauseUpdateReqVO extends ContractClauseBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "7146")
@NotNull(message = "编号不能为空")
private Long id;
}

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import com.yunxi.scm.module.xxjj.convert.contracttemplate.ContractTemplateConvert;
import com.yunxi.scm.module.xxjj.service.contracttemplate.ContractTemplateService;
@Tag(name = "管理后台 - 合同模板")
@RestController
@RequestMapping("/xxjj/contract-template")
@Validated
public class ContractTemplateController {
@Resource
private ContractTemplateService contractTemplateService;
@PostMapping("/create")
@Operation(summary = "创建合同模板")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:create')")
public CommonResult<Long> createContractTemplate(@Valid @RequestBody ContractTemplateCreateReqVO createReqVO) {
return success(contractTemplateService.createContractTemplate(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新合同模板")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:update')")
public CommonResult<Boolean> updateContractTemplate(@Valid @RequestBody ContractTemplateUpdateReqVO updateReqVO) {
contractTemplateService.updateContractTemplate(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除合同模板")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:delete')")
public CommonResult<Boolean> deleteContractTemplate(@RequestParam("id") Long id) {
contractTemplateService.deleteContractTemplate(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得合同模板")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:query')")
public CommonResult<ContractTemplateRespVO> getContractTemplate(@RequestParam("id") Long id) {
ContractTemplateDO contractTemplate = contractTemplateService.getContractTemplate(id);
return success(ContractTemplateConvert.INSTANCE.convert(contractTemplate));
}
@GetMapping("/list")
@Operation(summary = "获得合同模板列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:query')")
public CommonResult<List<ContractTemplateRespVO>> getContractTemplateList(@RequestParam("ids") Collection<Long> ids) {
List<ContractTemplateDO> list = contractTemplateService.getContractTemplateList(ids);
return success(ContractTemplateConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得合同模板分页")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:query')")
public CommonResult<PageResult<ContractTemplateRespVO>> getContractTemplatePage(@Valid ContractTemplatePageReqVO pageVO) {
PageResult<ContractTemplateDO> pageResult = contractTemplateService.getContractTemplatePage(pageVO);
return success(ContractTemplateConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出合同模板 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:export')")
@OperateLog(type = EXPORT)
public void exportContractTemplateExcel(@Valid ContractTemplateExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ContractTemplateDO> list = contractTemplateService.getContractTemplateList(exportReqVO);
// 导出 Excel
List<ContractTemplateExcelVO> datas = ContractTemplateConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "合同模板.xls", "数据", ContractTemplateExcelVO.class, datas);
}
}

@ -0,0 +1,37 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class ContractTemplateBaseVO {
@Schema(description = "模板名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "李四")
@NotNull(message = "模板名称不能为空")
private String name;
@Schema(description = "合同模板类型 参考字典contract_template_type", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "合同模板类型 参考字典contract_template_type不能为空")
private String type;
@Schema(description = "状态 参考字典contract_template_status", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "状态 参考字典contract_template_status不能为空")
private String status;
@Schema(description = "模板描述", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "模板描述不能为空")
private String describe;
@Schema(description = "配置项 json格式", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "配置项 json格式不能为空")
private String options;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同模板创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplateCreateReqVO extends ContractTemplateBaseVO {
}

@ -0,0 +1,45 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
/**
* Excel VO
*
* @author
*/
@Data
public class ContractTemplateExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("模板名称")
private String name;
@ExcelProperty(value = "合同模板类型 参考字典contract_template_type", converter = DictConvert.class)
@DictFormat("contract_template_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String type;
@ExcelProperty(value = "状态 参考字典contract_template_status", converter = DictConvert.class)
@DictFormat("contract_template_status") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String status;
@ExcelProperty("模板描述")
private String describe;
@ExcelProperty("配置项 json格式")
private String options;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,29 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同模板 Excel 导出 Request VO参数和 ContractTemplatePageReqVO 是一致的")
@Data
public class ContractTemplateExportReqVO {
@Schema(description = "模板名称", example = "李四")
private String name;
@Schema(description = "合同模板类型 参考字典contract_template_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_template_status", example = "1")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同模板分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplatePageReqVO extends PageParam {
@Schema(description = "模板名称", example = "李四")
private String name;
@Schema(description = "合同模板类型 参考字典contract_template_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_template_status", example = "1")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 合同模板 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplateRespVO extends ContractTemplateBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "21453")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同模板更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplateUpdateReqVO extends ContractTemplateBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "21453")
@NotNull(message = "编号不能为空")
private Long id;
}

@ -1,5 +1,6 @@
package com.yunxi.scm.module.xxjj.controller.admin.product;
import com.yunxi.scm.module.xxjj.dal.mysql.product.ProductMapper;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
@ -8,7 +9,6 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
@ -36,6 +36,8 @@ public class ProductController {
@Resource
private ProductService productService;
@Resource
private ProductMapper productMapper;
@PostMapping("/create")
@Operation(summary = "创建商品")
@ -107,4 +109,14 @@ public class ProductController {
return success(ProductConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/productUpdateStatus")
@Operation(summary = "改状态")
@PreAuthorize("@ss.hasPermission('xxjj:product:query1')")
public String productUpdateStatus(@Valid @RequestBody ProductUpdateReqVO updateReqVO) {
ProductDO productDO=productService.getProduct(updateReqVO.getId());
productDO.setProductStatus(updateReqVO.getProductStatus());
productMapper.updateById(productDO);
return "修改成功";
}
}

@ -300,6 +300,9 @@ public class ProductBaseVO {
@Schema(description = "生命周期")
private String lifeCycle;
@Schema(description = "送货选择")
private String deliverMode;
@Schema(description = "销售状态")
private String salesStatus;

@ -260,6 +260,9 @@ public class ProductExcelVO {
@ExcelProperty("质检比例")
private String qualityInspectionRatio;
@Schema(description = "送货选择")
private String deliverMode;
@ExcelProperty("质检频次")
private String qualityInspectionFrequency;

@ -225,6 +225,9 @@ public class ProductExportReqVO {
@Schema(description = "存储温度下限")
private String storageTemperatureDown;
@Schema(description = "送货选择")
private String deliverMode;
@Schema(description = "存储温度上限")
private String storageTemperatureUpper;

@ -222,6 +222,9 @@ public class ProductPageReqVO extends PageParam {
@Schema(description = "层数/板(存储)")
private String storageBoxBoardNum;
@Schema(description = "送货选择")
private String deliverMode;
@Schema(description = "温层(存储)(1:常温 2:恒温 3:冷藏 4:冷冻)")
private String storageTemperature;

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productbusiness.ProductBusinessDO;
import com.yunxi.scm.module.xxjj.convert.productbusiness.ProductBusinessConvert;
import com.yunxi.scm.module.xxjj.service.productbusiness.ProductBusinessService;
@Tag(name = "管理后台 - 商品表和业务线关联关系")
@RestController
@RequestMapping("/xxjj/product-business")
@Validated
public class ProductBusinessController {
@Resource
private ProductBusinessService productBusinessService;
@PostMapping("/create")
@Operation(summary = "创建商品表和业务线关联关系")
@PreAuthorize("@ss.hasPermission('xxjj:product-business:create')")
public CommonResult<Long> createProductBusiness(@Valid @RequestBody ProductBusinessCreateReqVO createReqVO) {
return success(productBusinessService.createProductBusiness(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新商品表和业务线关联关系")
@PreAuthorize("@ss.hasPermission('xxjj:product-business:update')")
public CommonResult<Boolean> updateProductBusiness(@Valid @RequestBody ProductBusinessUpdateReqVO updateReqVO) {
productBusinessService.updateProductBusiness(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除商品表和业务线关联关系")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:product-business:delete')")
public CommonResult<Boolean> deleteProductBusiness(@RequestParam("id") Long id) {
productBusinessService.deleteProductBusiness(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得商品表和业务线关联关系")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:product-business:query')")
public CommonResult<ProductBusinessRespVO> getProductBusiness(@RequestParam("id") Long id) {
ProductBusinessDO productBusiness = productBusinessService.getProductBusiness(id);
return success(ProductBusinessConvert.INSTANCE.convert(productBusiness));
}
@GetMapping("/list")
@Operation(summary = "获得商品表和业务线关联关系列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:product-business:query')")
public CommonResult<List<ProductBusinessRespVO>> getProductBusinessList(@RequestParam("ids") Collection<Long> ids) {
List<ProductBusinessDO> list = productBusinessService.getProductBusinessList(ids);
return success(ProductBusinessConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得商品表和业务线关联关系分页")
@PreAuthorize("@ss.hasPermission('xxjj:product-business:query')")
public CommonResult<PageResult<ProductBusinessRespVO>> getProductBusinessPage(@Valid ProductBusinessPageReqVO pageVO) {
PageResult<ProductBusinessDO> pageResult = productBusinessService.getProductBusinessPage(pageVO);
return success(ProductBusinessConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出商品表和业务线关联关系 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:product-business:export')")
@OperateLog(type = EXPORT)
public void exportProductBusinessExcel(@Valid ProductBusinessExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ProductBusinessDO> list = productBusinessService.getProductBusinessList(exportReqVO);
// 导出 Excel
List<ProductBusinessExcelVO> datas = ProductBusinessConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "商品表和业务线关联关系.xls", "数据", ProductBusinessExcelVO.class, datas);
}
}

@ -0,0 +1,25 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* 线 Base VO VO 使
* VO Swagger
*/
@Data
public class ProductBusinessBaseVO {
@Schema(description = "业务id", requiredMode = Schema.RequiredMode.REQUIRED, example = "6024")
@NotNull(message = "业务id不能为空")
private Long productId;
@Schema(description = "业务线id", requiredMode = Schema.RequiredMode.REQUIRED, example = "27659")
@NotNull(message = "业务线id不能为空")
private Long businessLineId;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 商品表和业务线关联关系创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductBusinessCreateReqVO extends ProductBusinessBaseVO {
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
/**
* 线 Excel VO
*
* @author
*/
@Data
public class ProductBusinessExcelVO {
@ExcelProperty("主键id")
private Long id;
@ExcelProperty("业务id")
private Long productId;
@ExcelProperty("业务线id")
private Long businessLineId;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,26 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 商品表和业务线关联关系 Excel 导出 Request VO参数和 ProductBusinessPageReqVO 是一致的")
@Data
public class ProductBusinessExportReqVO {
@Schema(description = "业务id", example = "6024")
private Long productId;
@Schema(description = "业务线id", example = "27659")
private Long businessLineId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,28 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 商品表和业务线关联关系分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductBusinessPageReqVO extends PageParam {
@Schema(description = "业务id", example = "6024")
private Long productId;
@Schema(description = "业务线id", example = "27659")
private Long businessLineId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 商品表和业务线关联关系 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductBusinessRespVO extends ProductBusinessBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "9153")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 商品表和业务线关联关系更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductBusinessUpdateReqVO extends ProductBusinessBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "9153")
@NotNull(message = "主键id不能为空")
private Long id;
}

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productlabelid.ProductLabelIdDO;
import com.yunxi.scm.module.xxjj.convert.productlabelid.ProductLabelIdConvert;
import com.yunxi.scm.module.xxjj.service.productlabelid.ProductLabelIdService;
@Tag(name = "管理后台 - 商品标签关联关系")
@RestController
@RequestMapping("/xxjj/product-label-id")
@Validated
public class ProductLabelIdController {
@Resource
private ProductLabelIdService productLabelIdService;
@PostMapping("/create")
@Operation(summary = "创建商品标签关联关系")
@PreAuthorize("@ss.hasPermission('xxjj:product-label-id:create')")
public CommonResult<Long> createProductLabelId(@Valid @RequestBody ProductLabelIdCreateReqVO createReqVO) {
return success(productLabelIdService.createProductLabelId(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新商品标签关联关系")
@PreAuthorize("@ss.hasPermission('xxjj:product-label-id:update')")
public CommonResult<Boolean> updateProductLabelId(@Valid @RequestBody ProductLabelIdUpdateReqVO updateReqVO) {
productLabelIdService.updateProductLabelId(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除商品标签关联关系")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:product-label-id:delete')")
public CommonResult<Boolean> deleteProductLabelId(@RequestParam("id") Long id) {
productLabelIdService.deleteProductLabelId(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得商品标签关联关系")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:product-label-id:query')")
public CommonResult<ProductLabelIdRespVO> getProductLabelId(@RequestParam("id") Long id) {
ProductLabelIdDO productLabelId = productLabelIdService.getProductLabelId(id);
return success(ProductLabelIdConvert.INSTANCE.convert(productLabelId));
}
@GetMapping("/list")
@Operation(summary = "获得商品标签关联关系列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:product-label-id:query')")
public CommonResult<List<ProductLabelIdRespVO>> getProductLabelIdList(@RequestParam("ids") Collection<Long> ids) {
List<ProductLabelIdDO> list = productLabelIdService.getProductLabelIdList(ids);
return success(ProductLabelIdConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得商品标签关联关系分页")
@PreAuthorize("@ss.hasPermission('xxjj:product-label-id:query')")
public CommonResult<PageResult<ProductLabelIdRespVO>> getProductLabelIdPage(@Valid ProductLabelIdPageReqVO pageVO) {
PageResult<ProductLabelIdDO> pageResult = productLabelIdService.getProductLabelIdPage(pageVO);
return success(ProductLabelIdConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出商品标签关联关系 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:product-label-id:export')")
@OperateLog(type = EXPORT)
public void exportProductLabelIdExcel(@Valid ProductLabelIdExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ProductLabelIdDO> list = productLabelIdService.getProductLabelIdList(exportReqVO);
// 导出 Excel
List<ProductLabelIdExcelVO> datas = ProductLabelIdConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "商品标签关联关系.xls", "数据", ProductLabelIdExcelVO.class, datas);
}
}

@ -0,0 +1,23 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class ProductLabelIdBaseVO {
@Schema(description = "商品id", example = "23915")
private Long productId;
@Schema(description = "标签id", example = "19298")
private Long labelId;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 商品标签关联关系创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductLabelIdCreateReqVO extends ProductLabelIdBaseVO {
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
/**
* Excel VO
*
* @author
*/
@Data
public class ProductLabelIdExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("商品id")
private Long productId;
@ExcelProperty("标签id")
private Long labelId;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,26 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 商品标签关联关系 Excel 导出 Request VO参数和 ProductLabelIdPageReqVO 是一致的")
@Data
public class ProductLabelIdExportReqVO {
@Schema(description = "商品id", example = "23915")
private Long productId;
@Schema(description = "标签id", example = "19298")
private Long labelId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,28 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 商品标签关联关系分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductLabelIdPageReqVO extends PageParam {
@Schema(description = "商品id", example = "23915")
private Long productId;
@Schema(description = "标签id", example = "19298")
private Long labelId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 商品标签关联关系 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductLabelIdRespVO extends ProductLabelIdBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "15723")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 商品标签关联关系更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductLabelIdUpdateReqVO extends ProductLabelIdBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "15723")
@NotNull(message = "编号不能为空")
private Long id;
}

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productmodificationitem0.ProductModificationItem0DO;
import com.yunxi.scm.module.xxjj.convert.productmodificationitem0.ProductModificationItem0Convert;
import com.yunxi.scm.module.xxjj.service.productmodificationitem0.ProductModificationItem0Service;
@Tag(name = "管理后台 - 批量修改单商品")
@RestController
@RequestMapping("/xxjj/product-modification-item0")
@Validated
public class ProductModificationItem0Controller {
@Resource
private ProductModificationItem0Service productModificationItem0Service;
@PostMapping("/create")
@Operation(summary = "创建批量修改单商品")
@PreAuthorize("@ss.hasPermission('xxjj:product-modification-item0:create')")
public CommonResult<Long> createProductModificationItem0(@Valid @RequestBody ProductModificationItem0CreateReqVO createReqVO) {
return success(productModificationItem0Service.createProductModificationItem0(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新批量修改单商品")
@PreAuthorize("@ss.hasPermission('xxjj:product-modification-item0:update')")
public CommonResult<Boolean> updateProductModificationItem0(@Valid @RequestBody ProductModificationItem0UpdateReqVO updateReqVO) {
productModificationItem0Service.updateProductModificationItem0(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除批量修改单商品")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:product-modification-item0:delete')")
public CommonResult<Boolean> deleteProductModificationItem0(@RequestParam("id") Long id) {
productModificationItem0Service.deleteProductModificationItem0(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得批量修改单商品")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:product-modification-item0:query')")
public CommonResult<ProductModificationItem0RespVO> getProductModificationItem0(@RequestParam("id") Long id) {
ProductModificationItem0DO productModificationItem0 = productModificationItem0Service.getProductModificationItem0(id);
return success(ProductModificationItem0Convert.INSTANCE.convert(productModificationItem0));
}
@GetMapping("/list")
@Operation(summary = "获得批量修改单商品列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:product-modification-item0:query')")
public CommonResult<List<ProductModificationItem0RespVO>> getProductModificationItem0List(@RequestParam("ids") Collection<Long> ids) {
List<ProductModificationItem0DO> list = productModificationItem0Service.getProductModificationItem0List(ids);
return success(ProductModificationItem0Convert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得批量修改单商品分页")
@PreAuthorize("@ss.hasPermission('xxjj:product-modification-item0:query')")
public CommonResult<PageResult<ProductModificationItem0RespVO>> getProductModificationItem0Page(@Valid ProductModificationItem0PageReqVO pageVO) {
PageResult<ProductModificationItem0DO> pageResult = productModificationItem0Service.getProductModificationItem0Page(pageVO);
return success(ProductModificationItem0Convert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出批量修改单商品 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:product-modification-item0:export')")
@OperateLog(type = EXPORT)
public void exportProductModificationItem0Excel(@Valid ProductModificationItem0ExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ProductModificationItem0DO> list = productModificationItem0Service.getProductModificationItem0List(exportReqVO);
// 导出 Excel
List<ProductModificationItem0ExcelVO> datas = ProductModificationItem0Convert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "批量修改单商品.xls", "数据", ProductModificationItem0ExcelVO.class, datas);
}
}

@ -0,0 +1,20 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class ProductModificationItem0BaseVO {
@Schema(description = "商品id", example = "23297")
private Long productId;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 批量修改单商品创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductModificationItem0CreateReqVO extends ProductModificationItem0BaseVO {
}

@ -0,0 +1,28 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
/**
* Excel VO
*
* @author
*/
@Data
public class ProductModificationItem0ExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("商品id")
private Long productId;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,23 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 批量修改单商品 Excel 导出 Request VO参数和 ProductModificationItem0PageReqVO 是一致的")
@Data
public class ProductModificationItem0ExportReqVO {
@Schema(description = "商品id", example = "23297")
private Long productId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,25 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 批量修改单商品分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductModificationItem0PageReqVO extends PageParam {
@Schema(description = "商品id", example = "23297")
private Long productId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 批量修改单商品 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductModificationItem0RespVO extends ProductModificationItem0BaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "31088")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 批量修改单商品更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductModificationItem0UpdateReqVO extends ProductModificationItem0BaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "31088")
@NotNull(message = "编号不能为空")
private Long id;
}

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productparametervalue.ProductParameterValueDO;
import com.yunxi.scm.module.xxjj.convert.productparametervalue.ProductParameterValueConvert;
import com.yunxi.scm.module.xxjj.service.productparametervalue.ProductParameterValueService;
@Tag(name = "管理后台 - 商品参数值")
@RestController
@RequestMapping("/xxjj/product-parameter-value")
@Validated
public class ProductParameterValueController {
@Resource
private ProductParameterValueService productParameterValueService;
@PostMapping("/create")
@Operation(summary = "创建商品参数值")
@PreAuthorize("@ss.hasPermission('xxjj:product-parameter-value:create')")
public CommonResult<Long> createProductParameterValue(@Valid @RequestBody ProductParameterValueCreateReqVO createReqVO) {
return success(productParameterValueService.createProductParameterValue(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新商品参数值")
@PreAuthorize("@ss.hasPermission('xxjj:product-parameter-value:update')")
public CommonResult<Boolean> updateProductParameterValue(@Valid @RequestBody ProductParameterValueUpdateReqVO updateReqVO) {
productParameterValueService.updateProductParameterValue(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除商品参数值")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:product-parameter-value:delete')")
public CommonResult<Boolean> deleteProductParameterValue(@RequestParam("id") Long id) {
productParameterValueService.deleteProductParameterValue(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得商品参数值")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:product-parameter-value:query')")
public CommonResult<ProductParameterValueRespVO> getProductParameterValue(@RequestParam("id") Long id) {
ProductParameterValueDO productParameterValue = productParameterValueService.getProductParameterValue(id);
return success(ProductParameterValueConvert.INSTANCE.convert(productParameterValue));
}
@GetMapping("/list")
@Operation(summary = "获得商品参数值列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:product-parameter-value:query')")
public CommonResult<List<ProductParameterValueRespVO>> getProductParameterValueList(@RequestParam("ids") Collection<Long> ids) {
List<ProductParameterValueDO> list = productParameterValueService.getProductParameterValueList(ids);
return success(ProductParameterValueConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得商品参数值分页")
@PreAuthorize("@ss.hasPermission('xxjj:product-parameter-value:query')")
public CommonResult<PageResult<ProductParameterValueRespVO>> getProductParameterValuePage(@Valid ProductParameterValuePageReqVO pageVO) {
PageResult<ProductParameterValueDO> pageResult = productParameterValueService.getProductParameterValuePage(pageVO);
return success(ProductParameterValueConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出商品参数值 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:product-parameter-value:export')")
@OperateLog(type = EXPORT)
public void exportProductParameterValueExcel(@Valid ProductParameterValueExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ProductParameterValueDO> list = productParameterValueService.getProductParameterValueList(exportReqVO);
// 导出 Excel
List<ProductParameterValueExcelVO> datas = ProductParameterValueConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "商品参数值.xls", "数据", ProductParameterValueExcelVO.class, datas);
}
}

@ -0,0 +1,23 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class ProductParameterValueBaseVO {
@Schema(description = "主表ID", example = "2958")
private Long parameterId;
@Schema(description = "参数值", example = "李四")
private String parameterName;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 商品参数值创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductParameterValueCreateReqVO extends ProductParameterValueBaseVO {
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
/**
* Excel VO
*
* @author
*/
@Data
public class ProductParameterValueExcelVO {
@ExcelProperty("ID")
private Long id;
@ExcelProperty("主表ID")
private Long parameterId;
@ExcelProperty("参数值")
private String parameterName;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,26 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 商品参数值 Excel 导出 Request VO参数和 ProductParameterValuePageReqVO 是一致的")
@Data
public class ProductParameterValueExportReqVO {
@Schema(description = "主表ID", example = "2958")
private Long parameterId;
@Schema(description = "参数值", example = "李四")
private String parameterName;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,28 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 商品参数值分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductParameterValuePageReqVO extends PageParam {
@Schema(description = "主表ID", example = "2958")
private Long parameterId;
@Schema(description = "参数值", example = "李四")
private String parameterName;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 商品参数值 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductParameterValueRespVO extends ProductParameterValueBaseVO {
@Schema(description = "ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "29318")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 商品参数值更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProductParameterValueUpdateReqVO extends ProductParameterValueBaseVO {
@Schema(description = "ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "29318")
@NotNull(message = "ID不能为空")
private Long id;
}

@ -1,6 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbasic;
import com.yunxi.scm.module.system.dal.dataobject.businesswarehouse.BusinessWarehouseDO;
import com.yunxi.scm.module.system.dal.dataobject.dept.DeptDO;
import com.yunxi.scm.module.system.service.businesswarehouse.BusinessWarehouseService;
import com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo.SubjectBusinessExportReqVO;
import com.yunxi.scm.module.xxjj.controller.admin.subjectcontacts.vo.SubjectContactsExportReqVO;
import com.yunxi.scm.module.xxjj.controller.admin.subjectrepresentative.vo.SubjectRepresentativeExportReqVO;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectbusiness.SubjectBusinessDO;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectcontacts.SubjectContactsDO;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectrepresentative.SubjectRepresentativeDO;
import com.yunxi.scm.module.xxjj.dal.mysql.subjectbasic.SubjectBasicMapper;
import com.yunxi.scm.module.xxjj.service.subjectbusiness.SubjectBusinessService;
import com.yunxi.scm.module.xxjj.service.subjectcontacts.SubjectContactsService;
import com.yunxi.scm.module.xxjj.service.subjectrepresentative.SubjectRepresentativeService;
import io.swagger.v3.oas.annotations.media.Schema;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
@ -37,6 +50,17 @@ public class SubjectBasicController {
@Resource
private SubjectBasicService subjectBasicService;
@Resource
private SubjectContactsService subjectContactsService;
@Resource
private SubjectRepresentativeService subjectRepresentativeService;
@Resource
private SubjectBusinessService subjectBusinessService;
@Resource
private BusinessWarehouseService businessWarehouseService;
@Resource
private SubjectBasicMapper subjectBasicMapper;
@PostMapping("/create")
@Operation(summary = "创建基础业务信息表(客户,供应商,服务商主体)")
@ -68,6 +92,23 @@ public class SubjectBasicController {
@PreAuthorize("@ss.hasPermission('xxjj:subject-basic:query')")
public CommonResult<SubjectBasicRespVO> getSubjectBasic(@RequestParam("id") Long id) {
SubjectBasicDO subjectBasic = subjectBasicService.getSubjectBasic(id);
SubjectContactsExportReqVO exportReqVO = new SubjectContactsExportReqVO();
exportReqVO.setBusinessId(id);
List<SubjectContactsDO> subjectContactsDOList = subjectContactsService.getSubjectContactsList(exportReqVO);
subjectBasic.setSubjectContactsDOList(subjectContactsDOList);
SubjectRepresentativeExportReqVO subjectRepresentativeExportReqVO = new SubjectRepresentativeExportReqVO();
subjectRepresentativeExportReqVO.setBusinessId(id);
List<SubjectRepresentativeDO> subjectRepresentativeDOList = subjectRepresentativeService.getSubjectRepresentativeList(subjectRepresentativeExportReqVO);
subjectBasic.setSubjectRepresentativeDOList(subjectRepresentativeDOList);
SubjectBusinessExportReqVO subjectBusinessExportReqVO = new SubjectBusinessExportReqVO();
subjectBusinessExportReqVO.setBusinessId(id);
List<SubjectBusinessDO> subjectBusinessDOList = subjectBusinessService.getSubjectBusinessList(subjectBusinessExportReqVO);
List<BusinessWarehouseDO> businessWarehouseDOList = new ArrayList<>();
for (SubjectBusinessDO subjectBusinessDO : subjectBusinessDOList) {
BusinessWarehouseDO businessWarehouseDO = businessWarehouseService.getBusinessWarehouse(subjectBusinessDO.getBusinessLineId());
businessWarehouseDOList.add(businessWarehouseDO);
}
subjectBasic.setBusinessWarehouseDOList(businessWarehouseDOList);
return success(SubjectBasicConvert.INSTANCE.convert(subjectBasic));
}
@ -88,6 +129,16 @@ public class SubjectBasicController {
return success(SubjectBasicConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/updateStatus")
@Operation(summary = "修改状态")
@PreAuthorize("@ss.hasPermission('xxjj:subject-basic:query')")
public void updateStatus(@Valid SubjectBasicPageReqVO pageVO) {
SubjectBasicDO subjectBasicDO = subjectBasicService.getSubjectBasic(pageVO.getId());
subjectBasicDO.setCustomerStatus(pageVO.getCustomerStatus());
subjectBasicMapper.updateById(subjectBasicDO);
}
@GetMapping("/export-excel")
@Operation(summary = "导出基础业务信息表(客户,供应商,服务商主体) Excel")
@PreAuthorize("@ss.hasPermission('xxjj:subject-basic:export')")

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectbusiness.SubjectBusinessDO;
import com.yunxi.scm.module.xxjj.convert.subjectbusiness.SubjectBusinessConvert;
import com.yunxi.scm.module.xxjj.service.subjectbusiness.SubjectBusinessService;
@Tag(name = "管理后台 - 主体业务线")
@RestController
@RequestMapping("/xxjj/subject-business")
@Validated
public class SubjectBusinessController {
@Resource
private SubjectBusinessService subjectBusinessService;
@PostMapping("/create")
@Operation(summary = "创建主体业务线")
@PreAuthorize("@ss.hasPermission('xxjj:subject-business:create')")
public CommonResult<Long> createSubjectBusiness(@Valid @RequestBody SubjectBusinessCreateReqVO createReqVO) {
return success(subjectBusinessService.createSubjectBusiness(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新主体业务线")
@PreAuthorize("@ss.hasPermission('xxjj:subject-business:update')")
public CommonResult<Boolean> updateSubjectBusiness(@Valid @RequestBody SubjectBusinessUpdateReqVO updateReqVO) {
subjectBusinessService.updateSubjectBusiness(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除主体业务线")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:subject-business:delete')")
public CommonResult<Boolean> deleteSubjectBusiness(@RequestParam("id") Long id) {
subjectBusinessService.deleteSubjectBusiness(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得主体业务线")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:subject-business:query')")
public CommonResult<SubjectBusinessRespVO> getSubjectBusiness(@RequestParam("id") Long id) {
SubjectBusinessDO subjectBusiness = subjectBusinessService.getSubjectBusiness(id);
return success(SubjectBusinessConvert.INSTANCE.convert(subjectBusiness));
}
@GetMapping("/list")
@Operation(summary = "获得主体业务线列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:subject-business:query')")
public CommonResult<List<SubjectBusinessRespVO>> getSubjectBusinessList(@RequestParam("ids") Collection<Long> ids) {
List<SubjectBusinessDO> list = subjectBusinessService.getSubjectBusinessList(ids);
return success(SubjectBusinessConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得主体业务线分页")
@PreAuthorize("@ss.hasPermission('xxjj:subject-business:query')")
public CommonResult<PageResult<SubjectBusinessRespVO>> getSubjectBusinessPage(@Valid SubjectBusinessPageReqVO pageVO) {
PageResult<SubjectBusinessDO> pageResult = subjectBusinessService.getSubjectBusinessPage(pageVO);
return success(SubjectBusinessConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出主体业务线 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:subject-business:export')")
@OperateLog(type = EXPORT)
public void exportSubjectBusinessExcel(@Valid SubjectBusinessExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<SubjectBusinessDO> list = subjectBusinessService.getSubjectBusinessList(exportReqVO);
// 导出 Excel
List<SubjectBusinessExcelVO> datas = SubjectBusinessConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "主体业务线.xls", "数据", SubjectBusinessExcelVO.class, datas);
}
}

@ -0,0 +1,28 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* 线 Base VO VO 使
* VO Swagger
*/
@Data
public class SubjectBusinessBaseVO {
@Schema(description = "业务id", requiredMode = Schema.RequiredMode.REQUIRED, example = "19518")
@NotNull(message = "业务id不能为空")
private Long businessId;
@Schema(description = "业务类型(0客户 1供应商 2服务商)", example = "2")
private String businessType;
@Schema(description = "业务线id", requiredMode = Schema.RequiredMode.REQUIRED, example = "7036")
@NotNull(message = "业务线id不能为空")
private Long businessLineId;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 主体业务线创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class SubjectBusinessCreateReqVO extends SubjectBusinessBaseVO {
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
/**
* 线 Excel VO
*
* @author
*/
@Data
public class SubjectBusinessExcelVO {
@ExcelProperty("主键id")
private Long id;
@ExcelProperty("业务id")
private Long businessId;
@ExcelProperty("业务类型(0客户 1供应商 2服务商)")
private String businessType;
@ExcelProperty("业务线id")
private Long businessLineId;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,29 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 主体业务线 Excel 导出 Request VO参数和 SubjectBusinessPageReqVO 是一致的")
@Data
public class SubjectBusinessExportReqVO {
@Schema(description = "业务id", example = "19518")
private Long businessId;
@Schema(description = "业务类型(0客户 1供应商 2服务商)", example = "2")
private String businessType;
@Schema(description = "业务线id", example = "7036")
private Long businessLineId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 主体业务线分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class SubjectBusinessPageReqVO extends PageParam {
@Schema(description = "业务id", example = "19518")
private Long businessId;
@Schema(description = "业务类型(0客户 1供应商 2服务商)", example = "2")
private String businessType;
@Schema(description = "业务线id", example = "7036")
private Long businessLineId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 主体业务线 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class SubjectBusinessRespVO extends SubjectBusinessBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "6041")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 主体业务线更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class SubjectBusinessUpdateReqVO extends SubjectBusinessBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "6041")
@NotNull(message = "主键id不能为空")
private Long id;
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.contractclause;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface ContractClauseConvert {
ContractClauseConvert INSTANCE = Mappers.getMapper(ContractClauseConvert.class);
ContractClauseDO convert(ContractClauseCreateReqVO bean);
ContractClauseDO convert(ContractClauseUpdateReqVO bean);
ContractClauseRespVO convert(ContractClauseDO bean);
List<ContractClauseRespVO> convertList(List<ContractClauseDO> list);
PageResult<ContractClauseRespVO> convertPage(PageResult<ContractClauseDO> page);
List<ContractClauseExcelVO> convertList02(List<ContractClauseDO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.contracttemplate;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface ContractTemplateConvert {
ContractTemplateConvert INSTANCE = Mappers.getMapper(ContractTemplateConvert.class);
ContractTemplateDO convert(ContractTemplateCreateReqVO bean);
ContractTemplateDO convert(ContractTemplateUpdateReqVO bean);
ContractTemplateRespVO convert(ContractTemplateDO bean);
List<ContractTemplateRespVO> convertList(List<ContractTemplateDO> list);
PageResult<ContractTemplateRespVO> convertPage(PageResult<ContractTemplateDO> page);
List<ContractTemplateExcelVO> convertList02(List<ContractTemplateDO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.productbusiness;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productbusiness.ProductBusinessDO;
/**
* 线 Convert
*
* @author
*/
@Mapper
public interface ProductBusinessConvert {
ProductBusinessConvert INSTANCE = Mappers.getMapper(ProductBusinessConvert.class);
ProductBusinessDO convert(ProductBusinessCreateReqVO bean);
ProductBusinessDO convert(ProductBusinessUpdateReqVO bean);
ProductBusinessRespVO convert(ProductBusinessDO bean);
List<ProductBusinessRespVO> convertList(List<ProductBusinessDO> list);
PageResult<ProductBusinessRespVO> convertPage(PageResult<ProductBusinessDO> page);
List<ProductBusinessExcelVO> convertList02(List<ProductBusinessDO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.productlabelid;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productlabelid.ProductLabelIdDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface ProductLabelIdConvert {
ProductLabelIdConvert INSTANCE = Mappers.getMapper(ProductLabelIdConvert.class);
ProductLabelIdDO convert(ProductLabelIdCreateReqVO bean);
ProductLabelIdDO convert(ProductLabelIdUpdateReqVO bean);
ProductLabelIdRespVO convert(ProductLabelIdDO bean);
List<ProductLabelIdRespVO> convertList(List<ProductLabelIdDO> list);
PageResult<ProductLabelIdRespVO> convertPage(PageResult<ProductLabelIdDO> page);
List<ProductLabelIdExcelVO> convertList02(List<ProductLabelIdDO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.productmodificationitem0;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productmodificationitem0.ProductModificationItem0DO;
/**
* Convert
*
* @author
*/
@Mapper
public interface ProductModificationItem0Convert {
ProductModificationItem0Convert INSTANCE = Mappers.getMapper(ProductModificationItem0Convert.class);
ProductModificationItem0DO convert(ProductModificationItem0CreateReqVO bean);
ProductModificationItem0DO convert(ProductModificationItem0UpdateReqVO bean);
ProductModificationItem0RespVO convert(ProductModificationItem0DO bean);
List<ProductModificationItem0RespVO> convertList(List<ProductModificationItem0DO> list);
PageResult<ProductModificationItem0RespVO> convertPage(PageResult<ProductModificationItem0DO> page);
List<ProductModificationItem0ExcelVO> convertList02(List<ProductModificationItem0DO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.productparametervalue;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productparametervalue.ProductParameterValueDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface ProductParameterValueConvert {
ProductParameterValueConvert INSTANCE = Mappers.getMapper(ProductParameterValueConvert.class);
ProductParameterValueDO convert(ProductParameterValueCreateReqVO bean);
ProductParameterValueDO convert(ProductParameterValueUpdateReqVO bean);
ProductParameterValueRespVO convert(ProductParameterValueDO bean);
List<ProductParameterValueRespVO> convertList(List<ProductParameterValueDO> list);
PageResult<ProductParameterValueRespVO> convertPage(PageResult<ProductParameterValueDO> page);
List<ProductParameterValueExcelVO> convertList02(List<ProductParameterValueDO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.subjectbusiness;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectbusiness.SubjectBusinessDO;
/**
* 线 Convert
*
* @author
*/
@Mapper
public interface SubjectBusinessConvert {
SubjectBusinessConvert INSTANCE = Mappers.getMapper(SubjectBusinessConvert.class);
SubjectBusinessDO convert(SubjectBusinessCreateReqVO bean);
SubjectBusinessDO convert(SubjectBusinessUpdateReqVO bean);
SubjectBusinessRespVO convert(SubjectBusinessDO bean);
List<SubjectBusinessRespVO> convertList(List<SubjectBusinessDO> list);
PageResult<SubjectBusinessRespVO> convertPage(PageResult<SubjectBusinessDO> page);
List<SubjectBusinessExcelVO> convertList02(List<SubjectBusinessDO> list);
}

@ -0,0 +1,63 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.contractclause;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("xxjj_contract_clause")
@KeySequence("xxjj_contract_clause_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ContractClauseDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
*
*/
private String title;
/**
* contract_clause_type
*
* {@link TODO contract_clause_type }
*/
private String type;
/**
* contract_clause_status
*
* {@link TODO contract_clause_status }
*/
private String status;
/**
*
*/
private String content;
/**
*
*/
private Short weight;
/**
*
*/
private String remark;
/**
*
*/
private String attachment;
}

@ -0,0 +1,55 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("xxjj_contract_template")
@KeySequence("xxjj_contract_template_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ContractTemplateDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
*
*/
private String name;
/**
* contract_template_type
*
* {@link TODO contract_template_type }
*/
private String type;
/**
* contract_template_status
*
* {@link TODO contract_template_status }
*/
private String status;
/**
*
*/
private String describe;
/**
* json
*/
private String options;
}

@ -434,6 +434,9 @@ public class ProductDO extends BaseDO {
@Schema(description = "销售状态")
private String salesStatus;
@Schema(description = "送货选择")
private String deliverMode;
//首选供应商
@TableField(exist = false)
private String supplierName;

@ -0,0 +1,39 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.productbusiness;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* 线 DO
*
* @author
*/
@TableName("xxjj_product_business")
@KeySequence("xxjj_product_business_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProductBusinessDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
* id
*/
private Long productId;
/**
* 线id
*/
private Long businessLineId;
}

@ -0,0 +1,39 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.productlabelid;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("xxjj_product_label_id")
@KeySequence("xxjj_product_label_id_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProductLabelIdDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
* id
*/
private Long productId;
/**
* id
*/
private Long labelId;
}

@ -0,0 +1,35 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.productmodificationitem0;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("xxjj_product_modification_item0")
@KeySequence("xxjj_product_modification_item0_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProductModificationItem0DO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
* id
*/
private Long productId;
}

@ -0,0 +1,39 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.productparametervalue;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("xxjj_product_parameter_value")
@KeySequence("xxjj_product_parameter_value_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProductParameterValueDO extends BaseDO {
/**
* ID
*/
@TableId
private Long id;
/**
* ID
*/
private Long parameterId;
/**
*
*/
private String parameterName;
}

@ -1,5 +1,8 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.subjectbasic;
import com.yunxi.scm.module.system.dal.dataobject.businesswarehouse.BusinessWarehouseDO;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectcontacts.SubjectContactsDO;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectrepresentative.SubjectRepresentativeDO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
@ -379,6 +382,8 @@ public class SubjectBasicDO extends BaseDO {
*/
private String cooperateType;
private String enterpriseId;
@TableField(exist = false)
private String creatorName;
/**
@ -399,4 +404,13 @@ public class SubjectBasicDO extends BaseDO {
/** 人员名称*/
@TableField(exist = false)
private String nickname;
@TableField(exist = false)
private List<SubjectContactsDO> subjectContactsDOList;
@TableField(exist = false)
private List<SubjectRepresentativeDO> subjectRepresentativeDOList;
@TableField(exist = false)
private List<BusinessWarehouseDO> businessWarehouseDOList;
}

@ -0,0 +1,43 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.subjectbusiness;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* 线 DO
*
* @author
*/
@TableName("xxjj_subject_business")
@KeySequence("xxjj_subject_business_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SubjectBusinessDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
* id
*/
private Long businessId;
/**
* (0 1 2)
*/
private String businessType;
/**
* 线id
*/
private Long businessLineId;
}

@ -0,0 +1,38 @@
package com.yunxi.scm.module.xxjj.dal.mysql.contractclause;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface ContractClauseMapper extends BaseMapperX<ContractClauseDO> {
default PageResult<ContractClauseDO> selectPage(ContractClausePageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ContractClauseDO>()
.eqIfPresent(ContractClauseDO::getTitle, reqVO.getTitle())
.eqIfPresent(ContractClauseDO::getType, reqVO.getType())
.eqIfPresent(ContractClauseDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractClauseDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractClauseDO::getId));
}
default List<ContractClauseDO> selectList(ContractClauseExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ContractClauseDO>()
.eqIfPresent(ContractClauseDO::getTitle, reqVO.getTitle())
.eqIfPresent(ContractClauseDO::getType, reqVO.getType())
.eqIfPresent(ContractClauseDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractClauseDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractClauseDO::getId));
}
}

@ -0,0 +1,38 @@
package com.yunxi.scm.module.xxjj.dal.mysql.contracttemplate;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface ContractTemplateMapper extends BaseMapperX<ContractTemplateDO> {
default PageResult<ContractTemplateDO> selectPage(ContractTemplatePageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ContractTemplateDO>()
.likeIfPresent(ContractTemplateDO::getName, reqVO.getName())
.eqIfPresent(ContractTemplateDO::getType, reqVO.getType())
.eqIfPresent(ContractTemplateDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractTemplateDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractTemplateDO::getId));
}
default List<ContractTemplateDO> selectList(ContractTemplateExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ContractTemplateDO>()
.likeIfPresent(ContractTemplateDO::getName, reqVO.getName())
.eqIfPresent(ContractTemplateDO::getType, reqVO.getType())
.eqIfPresent(ContractTemplateDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractTemplateDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractTemplateDO::getId));
}
}

@ -0,0 +1,36 @@
package com.yunxi.scm.module.xxjj.dal.mysql.productbusiness;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.productbusiness.ProductBusinessDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo.*;
/**
* 线 Mapper
*
* @author
*/
@Mapper
public interface ProductBusinessMapper extends BaseMapperX<ProductBusinessDO> {
default PageResult<ProductBusinessDO> selectPage(ProductBusinessPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ProductBusinessDO>()
.eqIfPresent(ProductBusinessDO::getProductId, reqVO.getProductId())
.eqIfPresent(ProductBusinessDO::getBusinessLineId, reqVO.getBusinessLineId())
.betweenIfPresent(ProductBusinessDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductBusinessDO::getId));
}
default List<ProductBusinessDO> selectList(ProductBusinessExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ProductBusinessDO>()
.eqIfPresent(ProductBusinessDO::getProductId, reqVO.getProductId())
.eqIfPresent(ProductBusinessDO::getBusinessLineId, reqVO.getBusinessLineId())
.betweenIfPresent(ProductBusinessDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductBusinessDO::getId));
}
}

@ -0,0 +1,36 @@
package com.yunxi.scm.module.xxjj.dal.mysql.productlabelid;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.productlabelid.ProductLabelIdDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface ProductLabelIdMapper extends BaseMapperX<ProductLabelIdDO> {
default PageResult<ProductLabelIdDO> selectPage(ProductLabelIdPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ProductLabelIdDO>()
.eqIfPresent(ProductLabelIdDO::getProductId, reqVO.getProductId())
.eqIfPresent(ProductLabelIdDO::getLabelId, reqVO.getLabelId())
.betweenIfPresent(ProductLabelIdDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductLabelIdDO::getId));
}
default List<ProductLabelIdDO> selectList(ProductLabelIdExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ProductLabelIdDO>()
.eqIfPresent(ProductLabelIdDO::getProductId, reqVO.getProductId())
.eqIfPresent(ProductLabelIdDO::getLabelId, reqVO.getLabelId())
.betweenIfPresent(ProductLabelIdDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductLabelIdDO::getId));
}
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.dal.mysql.productmodificationitem0;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.productmodificationitem0.ProductModificationItem0DO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface ProductModificationItem0Mapper extends BaseMapperX<ProductModificationItem0DO> {
default PageResult<ProductModificationItem0DO> selectPage(ProductModificationItem0PageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ProductModificationItem0DO>()
.eqIfPresent(ProductModificationItem0DO::getProductId, reqVO.getProductId())
.betweenIfPresent(ProductModificationItem0DO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductModificationItem0DO::getId));
}
default List<ProductModificationItem0DO> selectList(ProductModificationItem0ExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ProductModificationItem0DO>()
.eqIfPresent(ProductModificationItem0DO::getProductId, reqVO.getProductId())
.betweenIfPresent(ProductModificationItem0DO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductModificationItem0DO::getId));
}
}

@ -0,0 +1,36 @@
package com.yunxi.scm.module.xxjj.dal.mysql.productparametervalue;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.productparametervalue.ProductParameterValueDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface ProductParameterValueMapper extends BaseMapperX<ProductParameterValueDO> {
default PageResult<ProductParameterValueDO> selectPage(ProductParameterValuePageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ProductParameterValueDO>()
.eqIfPresent(ProductParameterValueDO::getParameterId, reqVO.getParameterId())
.likeIfPresent(ProductParameterValueDO::getParameterName, reqVO.getParameterName())
.betweenIfPresent(ProductParameterValueDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductParameterValueDO::getId));
}
default List<ProductParameterValueDO> selectList(ProductParameterValueExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ProductParameterValueDO>()
.eqIfPresent(ProductParameterValueDO::getParameterId, reqVO.getParameterId())
.likeIfPresent(ProductParameterValueDO::getParameterName, reqVO.getParameterName())
.betweenIfPresent(ProductParameterValueDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProductParameterValueDO::getId));
}
}

@ -0,0 +1,38 @@
package com.yunxi.scm.module.xxjj.dal.mysql.subjectbusiness;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectbusiness.SubjectBusinessDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.subjectbusiness.vo.*;
/**
* 线 Mapper
*
* @author
*/
@Mapper
public interface SubjectBusinessMapper extends BaseMapperX<SubjectBusinessDO> {
default PageResult<SubjectBusinessDO> selectPage(SubjectBusinessPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<SubjectBusinessDO>()
.eqIfPresent(SubjectBusinessDO::getBusinessId, reqVO.getBusinessId())
.eqIfPresent(SubjectBusinessDO::getBusinessType, reqVO.getBusinessType())
.eqIfPresent(SubjectBusinessDO::getBusinessLineId, reqVO.getBusinessLineId())
.betweenIfPresent(SubjectBusinessDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(SubjectBusinessDO::getId));
}
default List<SubjectBusinessDO> selectList(SubjectBusinessExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<SubjectBusinessDO>()
.eqIfPresent(SubjectBusinessDO::getBusinessId, reqVO.getBusinessId())
.eqIfPresent(SubjectBusinessDO::getBusinessType, reqVO.getBusinessType())
.eqIfPresent(SubjectBusinessDO::getBusinessLineId, reqVO.getBusinessLineId())
.betweenIfPresent(SubjectBusinessDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(SubjectBusinessDO::getId));
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.contractclause;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface ContractClauseService {
/**
*
*
* @param createReqVO
* @return
*/
Long createContractClause(@Valid ContractClauseCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateContractClause(@Valid ContractClauseUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteContractClause(Long id);
/**
*
*
* @param id
* @return
*/
ContractClauseDO getContractClause(Long id);
/**
*
*
* @param ids
* @return
*/
List<ContractClauseDO> getContractClauseList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<ContractClauseDO> getContractClausePage(ContractClausePageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<ContractClauseDO> getContractClauseList(ContractClauseExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.contractclause;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.contractclause.ContractClauseConvert;
import com.yunxi.scm.module.xxjj.dal.mysql.contractclause.ContractClauseMapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class ContractClauseServiceImpl implements ContractClauseService {
@Resource
private ContractClauseMapper contractClauseMapper;
@Override
public Long createContractClause(ContractClauseCreateReqVO createReqVO) {
// 插入
ContractClauseDO contractClause = ContractClauseConvert.INSTANCE.convert(createReqVO);
contractClauseMapper.insert(contractClause);
// 返回
return contractClause.getId();
}
@Override
public void updateContractClause(ContractClauseUpdateReqVO updateReqVO) {
// 校验存在
validateContractClauseExists(updateReqVO.getId());
// 更新
ContractClauseDO updateObj = ContractClauseConvert.INSTANCE.convert(updateReqVO);
contractClauseMapper.updateById(updateObj);
}
@Override
public void deleteContractClause(Long id) {
// 校验存在
validateContractClauseExists(id);
// 删除
contractClauseMapper.deleteById(id);
}
private void validateContractClauseExists(Long id) {
if (contractClauseMapper.selectById(id) == null) {
throw exception(CONTRACT_CLAUSE_NOT_EXISTS);
}
}
@Override
public ContractClauseDO getContractClause(Long id) {
return contractClauseMapper.selectById(id);
}
@Override
public List<ContractClauseDO> getContractClauseList(Collection<Long> ids) {
return contractClauseMapper.selectBatchIds(ids);
}
@Override
public PageResult<ContractClauseDO> getContractClausePage(ContractClausePageReqVO pageReqVO) {
return contractClauseMapper.selectPage(pageReqVO);
}
@Override
public List<ContractClauseDO> getContractClauseList(ContractClauseExportReqVO exportReqVO) {
return contractClauseMapper.selectList(exportReqVO);
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.contracttemplate;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface ContractTemplateService {
/**
*
*
* @param createReqVO
* @return
*/
Long createContractTemplate(@Valid ContractTemplateCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateContractTemplate(@Valid ContractTemplateUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteContractTemplate(Long id);
/**
*
*
* @param id
* @return
*/
ContractTemplateDO getContractTemplate(Long id);
/**
*
*
* @param ids
* @return
*/
List<ContractTemplateDO> getContractTemplateList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<ContractTemplateDO> getContractTemplatePage(ContractTemplatePageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<ContractTemplateDO> getContractTemplateList(ContractTemplateExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.contracttemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.contracttemplate.ContractTemplateConvert;
import com.yunxi.scm.module.xxjj.dal.mysql.contracttemplate.ContractTemplateMapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class ContractTemplateServiceImpl implements ContractTemplateService {
@Resource
private ContractTemplateMapper contractTemplateMapper;
@Override
public Long createContractTemplate(ContractTemplateCreateReqVO createReqVO) {
// 插入
ContractTemplateDO contractTemplate = ContractTemplateConvert.INSTANCE.convert(createReqVO);
contractTemplateMapper.insert(contractTemplate);
// 返回
return contractTemplate.getId();
}
@Override
public void updateContractTemplate(ContractTemplateUpdateReqVO updateReqVO) {
// 校验存在
validateContractTemplateExists(updateReqVO.getId());
// 更新
ContractTemplateDO updateObj = ContractTemplateConvert.INSTANCE.convert(updateReqVO);
contractTemplateMapper.updateById(updateObj);
}
@Override
public void deleteContractTemplate(Long id) {
// 校验存在
validateContractTemplateExists(id);
// 删除
contractTemplateMapper.deleteById(id);
}
private void validateContractTemplateExists(Long id) {
if (contractTemplateMapper.selectById(id) == null) {
throw exception(CONTRACT_TEMPLATE_NOT_EXISTS);
}
}
@Override
public ContractTemplateDO getContractTemplate(Long id) {
return contractTemplateMapper.selectById(id);
}
@Override
public List<ContractTemplateDO> getContractTemplateList(Collection<Long> ids) {
return contractTemplateMapper.selectBatchIds(ids);
}
@Override
public PageResult<ContractTemplateDO> getContractTemplatePage(ContractTemplatePageReqVO pageReqVO) {
return contractTemplateMapper.selectPage(pageReqVO);
}
@Override
public List<ContractTemplateDO> getContractTemplateList(ContractTemplateExportReqVO exportReqVO) {
return contractTemplateMapper.selectList(exportReqVO);
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.productbusiness;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productbusiness.ProductBusinessDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* 线 Service
*
* @author
*/
public interface ProductBusinessService {
/**
* 线
*
* @param createReqVO
* @return
*/
Long createProductBusiness(@Valid ProductBusinessCreateReqVO createReqVO);
/**
* 线
*
* @param updateReqVO
*/
void updateProductBusiness(@Valid ProductBusinessUpdateReqVO updateReqVO);
/**
* 线
*
* @param id
*/
void deleteProductBusiness(Long id);
/**
* 线
*
* @param id
* @return 线
*/
ProductBusinessDO getProductBusiness(Long id);
/**
* 线
*
* @param ids
* @return 线
*/
List<ProductBusinessDO> getProductBusinessList(Collection<Long> ids);
/**
* 线
*
* @param pageReqVO
* @return 线
*/
PageResult<ProductBusinessDO> getProductBusinessPage(ProductBusinessPageReqVO pageReqVO);
/**
* 线, Excel
*
* @param exportReqVO
* @return 线
*/
List<ProductBusinessDO> getProductBusinessList(ProductBusinessExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.productbusiness;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.productbusiness.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productbusiness.ProductBusinessDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.productbusiness.ProductBusinessConvert;
import com.yunxi.scm.module.xxjj.dal.mysql.productbusiness.ProductBusinessMapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* 线 Service
*
* @author
*/
@Service
@Validated
public class ProductBusinessServiceImpl implements ProductBusinessService {
@Resource
private ProductBusinessMapper productBusinessMapper;
@Override
public Long createProductBusiness(ProductBusinessCreateReqVO createReqVO) {
// 插入
ProductBusinessDO productBusiness = ProductBusinessConvert.INSTANCE.convert(createReqVO);
productBusinessMapper.insert(productBusiness);
// 返回
return productBusiness.getId();
}
@Override
public void updateProductBusiness(ProductBusinessUpdateReqVO updateReqVO) {
// 校验存在
validateProductBusinessExists(updateReqVO.getId());
// 更新
ProductBusinessDO updateObj = ProductBusinessConvert.INSTANCE.convert(updateReqVO);
productBusinessMapper.updateById(updateObj);
}
@Override
public void deleteProductBusiness(Long id) {
// 校验存在
validateProductBusinessExists(id);
// 删除
productBusinessMapper.deleteById(id);
}
private void validateProductBusinessExists(Long id) {
if (productBusinessMapper.selectById(id) == null) {
throw exception(PRODUCT_BUSINESS_NOT_EXISTS);
}
}
@Override
public ProductBusinessDO getProductBusiness(Long id) {
return productBusinessMapper.selectById(id);
}
@Override
public List<ProductBusinessDO> getProductBusinessList(Collection<Long> ids) {
return productBusinessMapper.selectBatchIds(ids);
}
@Override
public PageResult<ProductBusinessDO> getProductBusinessPage(ProductBusinessPageReqVO pageReqVO) {
return productBusinessMapper.selectPage(pageReqVO);
}
@Override
public List<ProductBusinessDO> getProductBusinessList(ProductBusinessExportReqVO exportReqVO) {
return productBusinessMapper.selectList(exportReqVO);
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.productlabelid;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productlabelid.ProductLabelIdDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface ProductLabelIdService {
/**
*
*
* @param createReqVO
* @return
*/
Long createProductLabelId(@Valid ProductLabelIdCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateProductLabelId(@Valid ProductLabelIdUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteProductLabelId(Long id);
/**
*
*
* @param id
* @return
*/
ProductLabelIdDO getProductLabelId(Long id);
/**
*
*
* @param ids
* @return
*/
List<ProductLabelIdDO> getProductLabelIdList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<ProductLabelIdDO> getProductLabelIdPage(ProductLabelIdPageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<ProductLabelIdDO> getProductLabelIdList(ProductLabelIdExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.productlabelid;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.productlabelid.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productlabelid.ProductLabelIdDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.productlabelid.ProductLabelIdConvert;
import com.yunxi.scm.module.xxjj.dal.mysql.productlabelid.ProductLabelIdMapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class ProductLabelIdServiceImpl implements ProductLabelIdService {
@Resource
private ProductLabelIdMapper productLabelIdMapper;
@Override
public Long createProductLabelId(ProductLabelIdCreateReqVO createReqVO) {
// 插入
ProductLabelIdDO productLabelId = ProductLabelIdConvert.INSTANCE.convert(createReqVO);
productLabelIdMapper.insert(productLabelId);
// 返回
return productLabelId.getId();
}
@Override
public void updateProductLabelId(ProductLabelIdUpdateReqVO updateReqVO) {
// 校验存在
validateProductLabelIdExists(updateReqVO.getId());
// 更新
ProductLabelIdDO updateObj = ProductLabelIdConvert.INSTANCE.convert(updateReqVO);
productLabelIdMapper.updateById(updateObj);
}
@Override
public void deleteProductLabelId(Long id) {
// 校验存在
validateProductLabelIdExists(id);
// 删除
productLabelIdMapper.deleteById(id);
}
private void validateProductLabelIdExists(Long id) {
if (productLabelIdMapper.selectById(id) == null) {
throw exception(PRODUCT_LABEL_ID_NOT_EXISTS);
}
}
@Override
public ProductLabelIdDO getProductLabelId(Long id) {
return productLabelIdMapper.selectById(id);
}
@Override
public List<ProductLabelIdDO> getProductLabelIdList(Collection<Long> ids) {
return productLabelIdMapper.selectBatchIds(ids);
}
@Override
public PageResult<ProductLabelIdDO> getProductLabelIdPage(ProductLabelIdPageReqVO pageReqVO) {
return productLabelIdMapper.selectPage(pageReqVO);
}
@Override
public List<ProductLabelIdDO> getProductLabelIdList(ProductLabelIdExportReqVO exportReqVO) {
return productLabelIdMapper.selectList(exportReqVO);
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.productmodificationitem0;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productmodificationitem0.ProductModificationItem0DO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface ProductModificationItem0Service {
/**
*
*
* @param createReqVO
* @return
*/
Long createProductModificationItem0(@Valid ProductModificationItem0CreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateProductModificationItem0(@Valid ProductModificationItem0UpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteProductModificationItem0(Long id);
/**
*
*
* @param id
* @return
*/
ProductModificationItem0DO getProductModificationItem0(Long id);
/**
*
*
* @param ids
* @return
*/
List<ProductModificationItem0DO> getProductModificationItem0List(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<ProductModificationItem0DO> getProductModificationItem0Page(ProductModificationItem0PageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<ProductModificationItem0DO> getProductModificationItem0List(ProductModificationItem0ExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.productmodificationitem0;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.productmodificationitem0.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productmodificationitem0.ProductModificationItem0DO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.productmodificationitem0.ProductModificationItem0Convert;
import com.yunxi.scm.module.xxjj.dal.mysql.productmodificationitem0.ProductModificationItem0Mapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class ProductModificationItem0ServiceImpl implements ProductModificationItem0Service {
@Resource
private ProductModificationItem0Mapper productModificationItem0Mapper;
@Override
public Long createProductModificationItem0(ProductModificationItem0CreateReqVO createReqVO) {
// 插入
ProductModificationItem0DO productModificationItem0 = ProductModificationItem0Convert.INSTANCE.convert(createReqVO);
productModificationItem0Mapper.insert(productModificationItem0);
// 返回
return productModificationItem0.getId();
}
@Override
public void updateProductModificationItem0(ProductModificationItem0UpdateReqVO updateReqVO) {
// 校验存在
validateProductModificationItem0Exists(updateReqVO.getId());
// 更新
ProductModificationItem0DO updateObj = ProductModificationItem0Convert.INSTANCE.convert(updateReqVO);
productModificationItem0Mapper.updateById(updateObj);
}
@Override
public void deleteProductModificationItem0(Long id) {
// 校验存在
validateProductModificationItem0Exists(id);
// 删除
productModificationItem0Mapper.deleteById(id);
}
private void validateProductModificationItem0Exists(Long id) {
if (productModificationItem0Mapper.selectById(id) == null) {
throw exception(PRODUCT_MODIFICATION_ITEM0_NOT_EXISTS);
}
}
@Override
public ProductModificationItem0DO getProductModificationItem0(Long id) {
return productModificationItem0Mapper.selectById(id);
}
@Override
public List<ProductModificationItem0DO> getProductModificationItem0List(Collection<Long> ids) {
return productModificationItem0Mapper.selectBatchIds(ids);
}
@Override
public PageResult<ProductModificationItem0DO> getProductModificationItem0Page(ProductModificationItem0PageReqVO pageReqVO) {
return productModificationItem0Mapper.selectPage(pageReqVO);
}
@Override
public List<ProductModificationItem0DO> getProductModificationItem0List(ProductModificationItem0ExportReqVO exportReqVO) {
return productModificationItem0Mapper.selectList(exportReqVO);
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.productparametervalue;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productparametervalue.ProductParameterValueDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface ProductParameterValueService {
/**
*
*
* @param createReqVO
* @return
*/
Long createProductParameterValue(@Valid ProductParameterValueCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateProductParameterValue(@Valid ProductParameterValueUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteProductParameterValue(Long id);
/**
*
*
* @param id
* @return
*/
ProductParameterValueDO getProductParameterValue(Long id);
/**
*
*
* @param ids
* @return
*/
List<ProductParameterValueDO> getProductParameterValueList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<ProductParameterValueDO> getProductParameterValuePage(ProductParameterValuePageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<ProductParameterValueDO> getProductParameterValueList(ProductParameterValueExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.productparametervalue;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.productparametervalue.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.productparametervalue.ProductParameterValueDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.productparametervalue.ProductParameterValueConvert;
import com.yunxi.scm.module.xxjj.dal.mysql.productparametervalue.ProductParameterValueMapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class ProductParameterValueServiceImpl implements ProductParameterValueService {
@Resource
private ProductParameterValueMapper productParameterValueMapper;
@Override
public Long createProductParameterValue(ProductParameterValueCreateReqVO createReqVO) {
// 插入
ProductParameterValueDO productParameterValue = ProductParameterValueConvert.INSTANCE.convert(createReqVO);
productParameterValueMapper.insert(productParameterValue);
// 返回
return productParameterValue.getId();
}
@Override
public void updateProductParameterValue(ProductParameterValueUpdateReqVO updateReqVO) {
// 校验存在
validateProductParameterValueExists(updateReqVO.getId());
// 更新
ProductParameterValueDO updateObj = ProductParameterValueConvert.INSTANCE.convert(updateReqVO);
productParameterValueMapper.updateById(updateObj);
}
@Override
public void deleteProductParameterValue(Long id) {
// 校验存在
validateProductParameterValueExists(id);
// 删除
productParameterValueMapper.deleteById(id);
}
private void validateProductParameterValueExists(Long id) {
if (productParameterValueMapper.selectById(id) == null) {
throw exception(PRODUCT_PARAMETER_VALUE_NOT_EXISTS);
}
}
@Override
public ProductParameterValueDO getProductParameterValue(Long id) {
return productParameterValueMapper.selectById(id);
}
@Override
public List<ProductParameterValueDO> getProductParameterValueList(Collection<Long> ids) {
return productParameterValueMapper.selectBatchIds(ids);
}
@Override
public PageResult<ProductParameterValueDO> getProductParameterValuePage(ProductParameterValuePageReqVO pageReqVO) {
return productParameterValueMapper.selectPage(pageReqVO);
}
@Override
public List<ProductParameterValueDO> getProductParameterValueList(ProductParameterValueExportReqVO exportReqVO) {
return productParameterValueMapper.selectList(exportReqVO);
}
}

@ -1,10 +1,18 @@
package com.yunxi.scm.module.xxjj.service.subjectbasic;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo.BusinessUserVO;
import com.yunxi.scm.module.system.dal.dataobject.businesswarehouse.BusinessWarehouseDO;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
import com.yunxi.scm.module.system.service.user.AdminUserService;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectbusiness.SubjectBusinessDO;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectcontacts.SubjectContactsDO;
import com.yunxi.scm.module.xxjj.dal.dataobject.subjectrepresentative.SubjectRepresentativeDO;
import com.yunxi.scm.module.xxjj.dal.mysql.subjectbusiness.SubjectBusinessMapper;
import com.yunxi.scm.module.xxjj.dal.mysql.subjectcontacts.SubjectContactsMapper;
import com.yunxi.scm.module.xxjj.dal.mysql.subjectrepresentative.SubjectRepresentativeMapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@ -34,12 +42,41 @@ public class SubjectBasicServiceImpl implements SubjectBasicService {
private SubjectBasicMapper subjectBasicMapper;
@Resource
private AdminUserService adminUserService;
@Resource
private SubjectRepresentativeMapper subjectRepresentativeMapper;
@Resource
private SubjectContactsMapper subjectContactsMapper;
@Resource
private SubjectBusinessMapper subjectBusinessMapper;
@Override
public Long createSubjectBasic(SubjectBasicCreateReqVO createReqVO) {
// 插入
SubjectBasicDO subjectBasic = SubjectBasicConvert.INSTANCE.convert(createReqVO);
subjectBasicMapper.insert(subjectBasic);
//保存主体人信息
List<SubjectRepresentativeDO> subjectRepresentativeDOList = createReqVO.getSubjectRepresentativeDOList();
for (SubjectRepresentativeDO subjectRepresentativeDO : subjectRepresentativeDOList) {
subjectRepresentativeDO.setBusinessType(subjectBasic.getBusinessType());
subjectRepresentativeDO.setBusinessId(subjectBasic.getId());
subjectRepresentativeMapper.insert(subjectRepresentativeDO);
}
//保存联系人人信息
List<SubjectContactsDO> subjectContactsDOList = createReqVO.getSubjectContactsDOList();
for (SubjectContactsDO subjectContactsDO : subjectContactsDOList) {
subjectContactsDO.setBusinessType(subjectBasic.getBusinessType());
subjectContactsDO.setBusinessId(subjectBasic.getId());
subjectContactsMapper.insert(subjectContactsDO);
}
//保存业务线信息
List<BusinessWarehouseDO> businessWarehouseDOList = createReqVO.getBusinessWarehouseDOList();
for (BusinessWarehouseDO businessWarehouseDO : businessWarehouseDOList) {
SubjectBusinessDO subjectBusinessDO = new SubjectBusinessDO();
subjectBusinessDO.setBusinessType(subjectBasic.getBusinessType());
subjectBusinessDO.setBusinessId(subjectBasic.getId());
subjectBusinessDO.setBusinessLineId(businessWarehouseDO.getId());
subjectBusinessMapper.insert(subjectBusinessDO);
}
// 返回
return subjectBasic.getId();
}
@ -51,6 +88,40 @@ public class SubjectBasicServiceImpl implements SubjectBasicService {
// 更新
SubjectBasicDO updateObj = SubjectBasicConvert.INSTANCE.convert(updateReqVO);
subjectBasicMapper.updateById(updateObj);
//保存主体人信息
List<SubjectRepresentativeDO> subjectRepresentativeDOList = updateReqVO.getSubjectRepresentativeDOList();
for (SubjectRepresentativeDO subjectRepresentativeDO : subjectRepresentativeDOList) {
subjectRepresentativeDO.setBusinessType(updateReqVO.getBusinessType());
subjectRepresentativeDO.setBusinessId(updateReqVO.getId());
if(subjectRepresentativeDO.getId() != null && subjectRepresentativeDO.getId() >= 0){
subjectRepresentativeMapper.updateById(subjectRepresentativeDO);
}else{
subjectRepresentativeMapper.insert(subjectRepresentativeDO);
}
}
//保存联系人人信息
List<SubjectContactsDO> subjectContactsDOList = updateReqVO.getSubjectContactsDOList();
for (SubjectContactsDO subjectContactsDO : subjectContactsDOList) {
subjectContactsDO.setBusinessType(updateReqVO.getBusinessType());
subjectContactsDO.setBusinessId(updateReqVO.getId());
if(subjectContactsDO.getId() != null && subjectContactsDO.getId() >= 0){
subjectContactsMapper.updateById(subjectContactsDO);
}else{
subjectContactsMapper.insert(subjectContactsDO);
}
}
//保存业务线信息
List<BusinessWarehouseDO> businessWarehouseDOList = updateReqVO.getBusinessWarehouseDOList();
QueryWrapper<SubjectBusinessDO> wrapper = new QueryWrapper<SubjectBusinessDO>()
.eq("business_id", updateReqVO.getId());
subjectBusinessMapper.delete(wrapper);
for (BusinessWarehouseDO businessWarehouseDO : businessWarehouseDOList) {
SubjectBusinessDO subjectBusinessDO = new SubjectBusinessDO();
subjectBusinessDO.setBusinessType(updateReqVO.getBusinessType());
subjectBusinessDO.setBusinessId(updateReqVO.getId());
subjectBusinessDO.setBusinessLineId(businessWarehouseDO.getId());
subjectBusinessMapper.insert(subjectBusinessDO);
}
}
@Override

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

Loading…
Cancel
Save