评价任务 改为dva数据流转模式

This commit is contained in:
linxd
2025-06-26 18:14:41 +08:00
parent f41639fd39
commit 527637cce3
14 changed files with 1698 additions and 970 deletions

View File

@ -148,7 +148,10 @@ const SupplierSelector: React.FC<SupplierSelectorProps> = ({
if (response && response.code === 200) {
// 请求成功,更新数据和分页信息
setTableListData(response.data.records || []);
setTableListData(response.data.records.map((item: any) => ({
...item,
supplierName: item.name,
})));
setPagination({
current: queryParams.pageNo,
pageSize: queryParams.pageSize,
@ -231,16 +234,26 @@ const SupplierSelector: React.FC<SupplierSelectorProps> = ({
const columns = [
{
title: '供应商名称',
dataIndex: 'name',
dataIndex: 'supplierName',
ellipsis: true,
render: (name: string) => (
<Tooltip placement="topLeft" title={name}>
{name}
render: (supplierName: string) => (
<Tooltip placement="topLeft" title={supplierName}>
{supplierName}
</Tooltip>
),
},
{
title: '所属品类',
title: '统一社会信用代码',
dataIndex: 'socialCreditCode',
ellipsis: true,
render: (socialCreditCode: string) => (
<Tooltip placement="topLeft" title={socialCreditCode}>
{socialCreditCode || '-'}
</Tooltip>
),
},
{
title: '准入品类',
dataIndex: 'categoryName',
ellipsis: true,
render: (categoryName: string) => (
@ -249,16 +262,7 @@ const SupplierSelector: React.FC<SupplierSelectorProps> = ({
</Tooltip>
),
},
{
title: '部门',
dataIndex: 'deptName',
ellipsis: true,
render: (deptName: string) => (
<Tooltip placement="topLeft" title={deptName}>
{deptName || '-'}
</Tooltip>
)
}
];
return (

1
src/models/readme.md Normal file
View File

@ -0,0 +1 @@
dva 模块

View File

@ -0,0 +1,347 @@
import { message } from 'antd';
import { addTask, getTaskDetail } from '@/servers/api/supplierEvaluate';
import type {
TaskDetailData,
TaskAddRequest,
TaskDetailResponse
} from '@/servers/dao/supplierEvaluateTask';
import type { TaskNotifyLowerUnits } from '@/dicts/supplierTaskDict';
import type { PersonnelItem } from '@/servers/dao/supplierEvaluateTask';
// Define the types for dva effects and reducers
type Effect = (action: { payload: any }, effects: { call: any; put: any; select: any }) => Generator<any, void, unknown>;
type Reducer<S> = (state: S, action: { payload: any }) => S;
/**
* 供应商任务管理模型状态接口
* 定义了整个模型的状态结构
*/
export interface SupplierTaskModelState {
currentStep: number; // 当前步骤索引从0开始
loading: boolean; // 提交加载状态
detailLoading: boolean; // 详情数据加载状态
taskFormData: Partial<TaskAddRequest>; // 任务表单数据
taskDetail: TaskDetailData | null; // 任务详情数据
userList: PersonnelItem[]; // 用户列表
}
/**
* 供应商任务管理模型类型接口
* 定义了模型的命名空间、状态、副作用和reducers
*/
export interface SupplierTaskModelType {
namespace: 'supplierTaskManage'; // 模型命名空间
state: SupplierTaskModelState; // 模型状态
effects: {
fetchTaskDetail: Effect; // 获取任务详情
submitTaskData: Effect; // 提交任务数据
updateFormData: Effect; // 更新表单数据
nextStep: Effect; // 下一步
prevStep: Effect; // 上一步
resetState: Effect; // 重置状态
};
reducers: {
saveCurrentStep: Reducer<SupplierTaskModelState>; // 保存当前步骤
saveLoading: Reducer<SupplierTaskModelState>; // 保存加载状态
saveDetailLoading: Reducer<SupplierTaskModelState>; // 保存详情加载状态
saveTaskFormData: Reducer<SupplierTaskModelState>; // 保存任务表单数据
saveTaskDetail: Reducer<SupplierTaskModelState>; // 保存任务详情数据
};
}
/**
* 供应商任务管理模型
* 用于管理供应商评价任务的添加、编辑流程和数据
*/
const SupplierTaskModel: SupplierTaskModelType = {
namespace: 'supplierTaskManage',
// 初始状态
state: {
currentStep: 0, // 当前步骤,默认为第一步
loading: false, // 提交加载状态
detailLoading: false, // 详情数据加载状态
taskFormData: {}, // 任务表单数据
taskDetail: null, // 任务详情数据
userList: [], // 用户列表
},
// 副作用处理函数
effects: {
/**
* 获取任务详情
* @param payload.taskId 任务ID
*/
*fetchTaskDetail({ payload }: { payload: { taskId: string } }, { call, put }: { call: any; put: any }) {
const { taskId } = payload;
yield put({ type: 'saveDetailLoading', payload: true });
try {
// 调用API获取任务详情
const response = (yield call(getTaskDetail, taskId)) as TaskDetailResponse;
if (response.success) {
const detail: TaskDetailData = response.data;
// 转换任务详情数据为表单数据结构
const taskFormData: Partial<TaskAddRequest> = {
id: detail.id || '',
evaluateTheme: detail.evaluateTheme || '',
startTime: detail.startTime || '',
endTime: detail.endTime || '',
templateId: detail.templateId || '',
categoryLimitation: detail.categoryLimitation || '0',
evaluateYear: detail.evaluateYear || '',
categoryId: detail.categoryId || undefined,
// 供应商数据转换添加id和name字段用于UI展示
selectedSuppliers: detail.blackSupplierVos.map((item) => ({
...item,
id: item.supplierId,
name: item.supplierName,
evaluators: item.userList,
})),
// 指标列表
indicatorList: detail.indicatorList || [],
// 供应商IDs与用户IDs
supplierIds: detail.supplierIds || [],
// 部门权重
taskDeptWeightList: detail.taskDeptWeightList || [],
//设置评价分工table回显 需处理
userList: detail.userList.map((user) => {
const matchedIndicator = detail.indicatorList?.find(
(indicator) => indicator.userId === user.userId
);
return {
...user,
name: user.userName,
id: user.userId,
indicatorIds: matchedIndicator?.indicatorIds || [],
};
}),
// 供应商与评价人员关联,用于分工步骤 需要以userList[]人员为维度,
// 关联出 indicatorList[]指标中的 userId,
// 关联出来的对象中的indicatorIds[]为指标id,
// 对象中的type不需要关注,只在保存时动态修改即可
suppliersWithEvaluators: detail.userList.map((user) => {
const matchedIndicator = detail.indicatorList?.find(
(indicator) => indicator.userId === user.userId
);
return {
...user,
name: user.userName,
id: user.userId,
indicatorIds: matchedIndicator?.indicatorIds || [],
};
}),
};
// 保存数据到状态
yield put({ type: 'saveTaskFormData', payload: taskFormData });
yield put({ type: 'saveTaskDetail', payload: detail });
} else {
message.error(response.message || '获取任务详情失败');
}
} catch (error) {
console.error('获取任务详情失败:', error);
message.error('获取任务详情失败');
} finally {
yield put({ type: 'saveDetailLoading', payload: false });
}
},
/**
* 提交任务数据
* @param payload.taskStatus 任务状态
* @param payload.isEditMode 是否为编辑模式
* @param payload.taskId 任务ID编辑模式必须
* @param payload.onSuccess 成功回调函数
*/
*submitTaskData(
{ payload }: { payload: { taskStatus: TaskNotifyLowerUnits | null; isEditMode: boolean; taskId: string; onSuccess?: () => void } },
{ call, put, select }: { call: any; put: any; select: any }
) {
const { taskStatus, isEditMode, taskId, onSuccess } = payload;
yield put({ type: 'saveLoading', payload: true });
try {
// 获取表单数据
const { taskFormData } = (yield select((state: any) => state.supplierTaskManage)) as { taskFormData: TaskAddRequest };
// 构建提交数据
let submitData: TaskAddRequest = {
evaluateTheme: taskFormData.evaluateTheme || '',
startTime: taskFormData.startTime || '',
endTime: taskFormData.endTime || '',
templateId: taskFormData.templateId || '',
categoryLimitation: taskFormData.categoryLimitation || '0',
evaluateYear: taskFormData.evaluateYear || '',
categoryId: taskFormData.categoryId || '',
taskStatus: taskStatus || null,
// 供应商IDs与评价人员IDs
supplierIds:
taskFormData.selectedSuppliers?.map((supplier: any) => {
// 从供应商的evaluators中提取用户ID
const userIds = supplier.evaluators?.map((evaluator: any) => evaluator.id) || [];
return {
id: supplier.id,
userIds,
};
}) || [],
// 指标列表
indicatorList:
taskFormData.indicatorList?.map((item: any) => ({
userId: item.userId,
// 评价类型如果用户关联了指标则为1(按指标)否则为0(按评价单)
type: item.indicatorIds && item.indicatorIds.length > 0 ? 1 : 0,
indicatorIds: item.indicatorIds || [],
})) || [],
// 部门权重列表过滤掉权重为0的
taskDeptWeightList:
taskFormData.taskDeptWeightList?.filter((item: any) => {
return item.weightValue && item.weightValue !== '0';
}) || [],
};
if (isEditMode) {
// 编辑模式添加ID字段
submitData = {
...submitData,
id: taskId,
};
}
const response = (yield call(addTask, submitData)) as API.Response;
if (response.success) {
message.success(isEditMode ? '任务更新成功' : '任务创建成功');
if (onSuccess) {
onSuccess();
}
} else {
message.error(response.message || '提交失败');
}
} catch (error) {
console.error('提交失败:', error);
message.error('提交失败');
} finally {
yield put({ type: 'saveLoading', payload: false });
}
},
/**
* 更新表单数据
* 处理不同步骤表单数据的变化,保持数据一致性
* @param payload 表单数据
*/
*updateFormData({ payload }: { payload: any }, { put, select }: { put: any; select: any }) {
// 获取当前表单数据
const { taskFormData } = (yield select((state: any) => state.supplierTaskManage)) as { taskFormData: TaskAddRequest };
// 合并新的表单数据
const updatedFormData = { ...taskFormData, ...payload };
// 处理供应商选择更新
if (payload.selectedSuppliers) {
// 确保每个供应商都有evaluators字段
const suppliersWithEvaluators = payload.selectedSuppliers.map((supplier: any) => ({
...supplier,
evaluators: supplier.evaluators || [], // 确保evaluators字段存在
}));
updatedFormData.selectedSuppliers = suppliersWithEvaluators;
}
// 处理评价人员更新 - 保持suppliersWithEvaluators和selectedSuppliers同步
if (payload.suppliersWithEvaluators) {
const evaluatedSuppliers = payload.suppliersWithEvaluators;
updatedFormData.suppliersWithEvaluators = evaluatedSuppliers;
updatedFormData.selectedSuppliers = evaluatedSuppliers; // 同步更新selectedSuppliers
}
// 处理部门权重
if (payload.taskDeptWeightList) {
updatedFormData.taskDeptWeightList = payload.taskDeptWeightList;
}
console.log(updatedFormData)
// 保存更新后的表单数据
yield put({ type: 'saveTaskFormData', payload: updatedFormData });
},
/**
* 下一步
* 将当前步骤索引加1
*/
*nextStep(_: any, { put, select }: { put: any; select: any }) {
const { currentStep } = (yield select((state: any) => state.supplierTaskManage)) as { currentStep: number };
yield put({ type: 'saveCurrentStep', payload: currentStep + 1 });
},
/**
* 上一步
* 将当前步骤索引减1
*/
*prevStep(_: any, { put, select }: { put: any; select: any }) {
const { currentStep } = (yield select((state: any) => state.supplierTaskManage)) as { currentStep: number };
yield put({ type: 'saveCurrentStep', payload: currentStep - 1 });
},
/**
* 重置状态
* 清空表单数据并将步骤重置为第一步
*/
*resetState(_: any, { put }: { put: any }) {
// 重置表单数据
yield put({
type: 'saveTaskFormData',
payload: {}
});
// 重置步骤到第一步
yield put({
type: 'saveCurrentStep',
payload: 0
});
},
},
// reducers用于更新状态
reducers: {
/**
* 保存当前步骤
*/
saveCurrentStep(state, { payload }) {
return { ...state, currentStep: payload };
},
/**
* 保存加载状态
*/
saveLoading(state, { payload }) {
return { ...state, loading: payload };
},
/**
* 保存详情加载状态
*/
saveDetailLoading(state, { payload }) {
return { ...state, detailLoading: payload };
},
/**
* 保存任务表单数据
*/
saveTaskFormData(state, { payload }) {
return { ...state, taskFormData: payload };
},
/**
* 保存任务详情数据
*/
saveTaskDetail(state, { payload }) {
return { ...state, taskDetail: payload };
},
},
};
export default SupplierTaskModel;

View File

@ -5,28 +5,36 @@ import { getAllTemplates } from '@/servers/api/supplierEvaluate';
import CategorySelector from '@/components/CategorySelector';
import styles from '../supplierTaskManageAdd.less';
import { CategoryLimitationType } from '@/dicts/supplierTemplateDict';
import type { TaskAddRequest } from '@/servers/types/supplierEvaluateTask';
import type { Dispatch } from 'umi';
import { connect } from 'umi';
import type { SupplierTaskModelState } from '@/models/supplierTaskManage';
const { Option } = Select;
interface BasicInfoStepProps {
formData: Partial<TaskAddRequest>;
onFormDataChange: (data: TaskAddRequest) => void;
}
interface TemplateItem {
id: string;
templateName: string;
categoryLimitation?: string;
}
const BasicInfoStep = forwardRef<any, BasicInfoStepProps>(({ formData, onFormDataChange }, ref) => {
interface BasicInfoStepProps {
supplierTaskManage: SupplierTaskModelState;
dispatch: Dispatch;
innerRef?: any; // 使用 innerRef 作为属性名
}
// 定义组件,使用 innerRef 代替直接的 ref
const BasicInfoStepComponent = (props: BasicInfoStepProps) => {
const { supplierTaskManage, dispatch, innerRef } = props;
const [form] = Form.useForm();
const [templates, setTemplates] = useState<TemplateItem[]>([]);
const [loading, setLoading] = useState<boolean>(false);
// 暴露表单方法给父组件
useImperativeHandle(ref, () => ({
// 从props中获取状态
const { taskFormData } = supplierTaskManage;
// 暴露表单方法给父组件,使用 innerRef
useImperativeHandle(innerRef, () => ({
validateFields: () => form.validateFields(),
getFieldsValue: () => form.getFieldsValue(),
setFieldsValue: (values: any) => form.setFieldsValue(values),
@ -52,27 +60,31 @@ const BasicInfoStep = forwardRef<any, BasicInfoStepProps>(({ formData, onFormDat
fetchTemplates();
// 初始化表单数据
if (formData) {
form.setFieldsValue(formData);
if (taskFormData) {
form.setFieldsValue(taskFormData);
}
}, []);
// 当formData变化时更新表单值
// 当taskFormData变化时更新表单值
useEffect(() => {
if (formData) {
if (taskFormData) {
// 处理日期字段,确保正确设置
const formValues = {
...formData,
startTime: formData.startTime ? moment(formData.startTime) : undefined,
endTime: formData.endTime ? moment(formData.endTime) : undefined,
...taskFormData,
startTime: taskFormData.startTime ? moment(taskFormData.startTime) : undefined,
endTime: taskFormData.endTime ? moment(taskFormData.endTime) : undefined,
};
form.setFieldsValue(formValues);
}
}, [formData, form]);
}, [taskFormData, form]);
// 表单值变化时触发
const handleValuesChange = (changedValues: any, allValues: any) => {
onFormDataChange(allValues);
// 使用dispatch更新model中的数据
dispatch({
type: 'supplierTaskManage/updateFormData',
payload: allValues,
});
};
// 年度选项生成
@ -87,9 +99,9 @@ const BasicInfoStep = forwardRef<any, BasicInfoStepProps>(({ formData, onFormDat
// 判断是否显示品类选择器
const shouldShowCategorySelector = useCallback(() => {
const categoryLimitation = formData.categoryLimitation;
const categoryLimitation = taskFormData.categoryLimitation;
return categoryLimitation === CategoryLimitationType.LIMITED;
}, [formData]);
}, [taskFormData]);
return (
@ -100,8 +112,8 @@ const BasicInfoStep = forwardRef<any, BasicInfoStepProps>(({ formData, onFormDat
layout="vertical"
onValuesChange={handleValuesChange}
initialValues={{
...formData,
categoryLimitation: formData.categoryLimitation || '0',
...taskFormData,
categoryLimitation: taskFormData.categoryLimitation || '0',
}}
>
<Row gutter={24}>
@ -203,6 +215,18 @@ const BasicInfoStep = forwardRef<any, BasicInfoStepProps>(({ formData, onFormDat
</Card>
</div>
);
});
};
// 连接 Dva model
const ConnectedComponent = connect(
({ supplierTaskManage }: { supplierTaskManage: SupplierTaskModelState }) => ({
supplierTaskManage,
})
)(BasicInfoStepComponent);
// 外层转发 ref 到 innerRef
const BasicInfoStep = forwardRef((props: any, ref) => (
<ConnectedComponent {...props} innerRef={ref} />
));
export default BasicInfoStep;

View File

@ -3,30 +3,17 @@ import React, {
useEffect,
forwardRef,
useImperativeHandle,
useMemo,
useCallback,
useRef,
} from 'react';
import {
Card,
Table,
Tag,
Switch,
Space,
Button,
message,
Modal,
Radio,
Checkbox,
Row,
Col,
Spin,
} from 'antd';
import { Table, Tag, Space, Button, message, Modal, Spin } from 'antd';
import type { PersonnelItem } from '@/servers/types/evaluator';
import type { ColumnsType } from 'antd/es/table';
import EvaluateTemplateTable from '@/components/EvaluateTemplateTable';
import { getTemplateDetail } from '@/servers/api/supplierEvaluate';
import type { TaskAddRequest } from '@/servers/types/supplierEvaluateTask';
import type { Dispatch } from 'umi';
import { connect } from 'umi';
import type { SupplierTaskModelState } from '@/models/supplierTaskManage';
// 评价指标类型定义
interface IndicatorItem {
@ -37,8 +24,9 @@ interface IndicatorItem {
// 组件接收的Props定义
interface DivisionStepProps {
formData: Partial<TaskAddRequest>;
onFormDataChange?: (values: Partial<TaskAddRequest>) => void;
supplierTaskManage: SupplierTaskModelState;
dispatch: Dispatch;
innerRef?: any; // 使用 innerRef 作为属性名
}
// 评价方式枚举
@ -49,7 +37,13 @@ enum EvaluateType {
INDICATOR = 1, // 按指标评价(部分指标)
}
const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataChange }, ref) => {
// 定义组件,使用 innerRef 代替直接的 ref
const DivisionStepComponent = (props: DivisionStepProps) => {
const { supplierTaskManage, dispatch, innerRef } = props;
// 从 model 获取表单数据,避免通过 props 层层传递
const { taskFormData } = supplierTaskManage;
// 从上一步获取的评价人员列表
const [evaluators, setEvaluators] = useState<PersonnelItem[]>([]);
@ -60,12 +54,6 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
indicatorIds: string[];
};
}>({});
// const [indicatorAssignments, setIndicatorAssignments] = useState<{
// [userId: string]: {
// type: EvaluateType;
// indicatorIds: string[];
// };
// }>({});
// 选中的行keys
const [selectedRowKeys, setSelectedRowKeys] = useState<React.Key[]>([]);
@ -79,9 +67,6 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
// 批量指标设置弹窗可见性
const [batchTemplateModalVisible, setBatchTemplateModalVisible] = useState(false);
// 批量选择的指标
const [batchSelectedIndicators, setBatchSelectedIndicators] = useState<string[]>([]);
// 批量选择的模板项
const [batchSelectedTemplateItems, setBatchSelectedTemplateItems] = useState<any[]>([]);
@ -187,10 +172,23 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
setLoading(false);
}
};
/**
* 更新表单数据
* 将本地状态同步到 Dva model
* @param updatedData 要更新的部分数据
*/
const updateFormData = (updatedData: any) => {
// 通过dispatch更新model中的数据
dispatch({
type: 'supplierTaskManage/updateFormData', // action类型
payload: {
...updatedData,
},
});
};
// 监听templateId变化获取模板详情
useEffect(() => {
fetchTemplateDetail(formData.templateId as string);
fetchTemplateDetail(taskFormData.templateId as string);
}, []);
// 处理行选择变化
@ -220,39 +218,42 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
const handleCloseBatchTemplateModal = () => {
setBatchTemplateModalVisible(false);
};
// 批量设置指标分工
const handleBatchSetDivision = () => {
// 获取选中的评价人员
const selectedEvaluators = evaluators.filter((evaluator) =>
selectedRowKeys.includes(evaluator.id),
// 处理指标选择 提取二级指标id
const getIndicatorNdListIds = (selectedItems: any[]) => {
const indicatorNdList = selectedItems.map((item) => item.indicatorNdList);
const indicatorNdListIds = indicatorNdList.flatMap((item) =>
item.map((ndItem: any) => ndItem.id),
);
// 提取所有选中指标的ID
const selectedIndicatorIds: string[] = [];
// 从选中的模板项中提取所有指标ID
batchSelectedTemplateItems.forEach((stItem) => {
// 添加二级指标ID
if (stItem.indicatorNdList && stItem.indicatorNdList.length > 0) {
stItem.indicatorNdList.forEach((ndItem: any) => {
selectedIndicatorIds.push(ndItem.id);
});
return indicatorNdListIds;
};
// 处理指标,将处理后的指标放到dva中,同步处理userList,展示table
const handleIndicatorAssignment = (indicatorNdListIds: string[]) => {
// 读取dva中的indicatorList
const indicatorList = JSON.parse(JSON.stringify(taskFormData?.indicatorList));
// 将指标id塞到当前激活的评价人员中
indicatorList?.map((item: any) => {
// 判断当前激活的评价人员和选择评价人构建的userId一直
if (item.userId === currentUserId) {
item.indicatorIds = [...new Set([...item.indicatorIds, ...indicatorNdListIds])];
}
});
// 更新指标分配数据
const newAssignments = { ...indicatorAssignments.current };
selectedEvaluators.forEach((evaluator) => {
newAssignments[evaluator.id] = {
// 评价类型如果用户关联了指标则为1(按指标)否则为0(按评价单)
type: selectedIndicatorIds.length > 0 ? EvaluateType.INDICATOR : EvaluateType.ALL,
indicatorIds: selectedIndicatorIds,
};
// 构建userList带指标id 为了表单回显
const userList = JSON.parse(JSON.stringify(taskFormData?.userList));
userList?.map((item: any) => {
if (item.id === currentUserId) {
item.indicatorIds = indicatorNdListIds;
}
});
indicatorAssignments.current = newAssignments;
updateFormData({
indicatorList,
userList,
});
};
// 批量设置指标分工
const handleBatchSetDivision = () => {
// 将选择回来的指标提取二级指标id
const indicatorNdListIds = getIndicatorNdListIds(batchSelectedTemplateItems);
handleIndicatorAssignment(indicatorNdListIds);
setBatchTemplateModalVisible(false);
message.success(`已为${selectedRowKeys.length}名评价人员设置分工`);
};
@ -274,7 +275,6 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
// 处理模板指标选择
const handleTemplateItemsSelect = (selectedItems: any[]) => {
console.log(selectedItems);
setSelectedTemplateItems(selectedItems);
};
@ -284,49 +284,29 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
message.warning('未选择评价人员');
return;
}
// 提取所有选中指标的ID
const selectedIndicatorIds: string[] = [];
// 从选中的模板项中提取所有指标ID
selectedTemplateItems.forEach((stItem) => {
// 添加二级指标ID
if (stItem.indicatorNdList && stItem.indicatorNdList.length > 0) {
stItem.indicatorNdList.forEach((ndItem: any) => {
selectedIndicatorIds.push(ndItem.id);
});
}
});
// 更新指标分配
const newAssignments = { ...indicatorAssignments.current };
newAssignments[currentUserId] = {
// 评价类型如果用户关联了指标则为1(按指标)否则为0(按评价单)
type: selectedIndicatorIds.length > 0 ? EvaluateType.INDICATOR : EvaluateType.ALL,
indicatorIds: selectedIndicatorIds,
};
indicatorAssignments.current = newAssignments;
// 将选择回来的指标提取二级指标id
const indicatorNdListIds = getIndicatorNdListIds(selectedTemplateItems);
handleIndicatorAssignment(indicatorNdListIds);
setTemplateViewModalVisible(false);
message.success('已设置评价人员指标分工');
};
// 查看评价人员的指标分工
const handleViewAssignment = (userId: string) => {
const assignment = indicatorAssignments.current[userId];
const handleViewAssignment = (person: PersonnelItem) => {
const assignment = person.indicatorIds;
if (!assignment) {
message.info('该评价人员尚未设置分工');
return;
}
setCurrentUserId(userId);
setCurrentUserId(person.id);
setLoading(true);
// 获取该评价人员的指标ID
const indicatorIds = getUserIndicatorIds(userId);
const indicatorIds = person.indicatorIds;
// 过滤模板数据
const filtered = filterTemplateDataByIds(templateData, indicatorIds);
const filtered = filterTemplateDataByIds(templateData, indicatorIds || []);
setFilteredIndicators(filtered);
setLoading(false);
@ -361,10 +341,10 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
// 初始化从formData中提取指标分配数据
useEffect(() => {
if (formData.indicatorList && formData.indicatorList.length > 0) {
if (taskFormData.indicatorList && taskFormData.indicatorList.length > 0) {
// 如果已有指标分配数据,直接使用
const assignments: any = {};
formData.indicatorList.forEach((item: any) => {
taskFormData.indicatorList.forEach((item: any) => {
assignments[item.userId] = {
type: item.type,
indicatorIds: item.indicatorIds || [],
@ -372,85 +352,16 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
});
indicatorAssignments.current = assignments;
}
}, [formData.indicatorList]);
}, [taskFormData.indicatorList]);
// 从上一步获取评价人员列表 - 避免频繁更新
useEffect(() => {
if (!formData.suppliersWithEvaluators) return;
// 从所有供应商中提取评价人员列表
const allEvaluators: PersonnelItem[] = [];
formData.suppliersWithEvaluators.forEach((supplier: any) => {
if (supplier.evaluators && supplier.evaluators.length > 0) {
supplier.evaluators.forEach((evaluator: PersonnelItem) => {
// 检查是否已存在(避免重复)
if (!allEvaluators.some((e) => e.id === evaluator.id)) {
allEvaluators.push({
...evaluator,
// 添加单位和员工编号,假设这些字段可能不存在
company: evaluator.company || supplier.supplierName || '未知单位',
employeeNumber: evaluator.employeeNumber || `EMP${evaluator.id.slice(-4)}`,
department: evaluator.department || '未知部门',
});
}
});
}
});
setEvaluators(allEvaluators);
}, [formData.suppliersWithEvaluators]);
// 为评价人员初始化指标分配数据 - 作为单独的效果处理
useEffect(() => {
// 检查是否有新的评价人员需要初始化
const newAssignments = { ...indicatorAssignments.current };
let hasNewAssignments = false;
evaluators.forEach((evaluator) => {
if (!indicatorAssignments.current[evaluator.id]) {
newAssignments[evaluator.id] = {
type: EvaluateType.ALL,
indicatorIds: [],
};
hasNewAssignments = true;
}
});
if (hasNewAssignments) {
indicatorAssignments.current = newAssignments;
}
}, [evaluators, indicatorAssignments]);
// 同步数据回表单 - 使用防抖确保不会频繁触发
const previousValueRef = React.useRef<string>('');
useEffect(() => {
// 若当前还未初始化完成(没有任何指标数据),不应向父组件同步
if (evaluators.length === 0 || Object.keys(indicatorAssignments.current).length === 0) {
return;
}
// 将评价人员列表和指标分配数据同步回表单
const indicatorList = evaluators.map((evaluator) => ({
userId: evaluator.id,
userName: evaluator.name,
type: indicatorAssignments.current[evaluator.id]?.type ?? EvaluateType.ALL,
indicatorIds: indicatorAssignments.current[evaluator.id]?.indicatorIds ?? [],
}));
// 使用JSON字符串比较确保只有在真正变化时才更新
const currentValue = JSON.stringify(indicatorList);
if (currentValue !== previousValueRef.current) {
previousValueRef.current = currentValue;
onFormDataChange?.({
...formData,
indicatorList,
});
}
}, [evaluators, formData, onFormDataChange]);
if (!taskFormData.userList) return;
setEvaluators(taskFormData.userList);
}, [taskFormData.userList]);
// 暴露给父组件的方法
useImperativeHandle(ref, () => ({
useImperativeHandle(innerRef, () => ({
validate: () => {
if (evaluators.length === 0) {
return {
@ -462,6 +373,7 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
},
}));
// 选择完
// 获取当前评价人员名称
const getCurrentEvaluatorName = () => {
const evaluator = evaluators.find((e) => e.id === currentUserId);
@ -503,7 +415,7 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
<Button type="link" onClick={() => handleAssignIndicators(record.id)}>
</Button>
<Button type="link" onClick={() => handleViewAssignment(record.id)}>
<Button type="link" onClick={() => handleViewAssignment(record)}>
</Button>
<Button type="link" onClick={() => handleRemoveEvaluator(record.id)}>
@ -568,7 +480,7 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
</Spin>
</Modal>
{/* 评价指标模板查看弹窗 */}
{/* 设置评价指标分工 */}
<Modal
title="设置评价指标分工"
visible={templateViewModalVisible}
@ -625,6 +537,22 @@ const DivisionStep = forwardRef<any, DivisionStepProps>(({ formData, onFormDataC
</Modal>
</div>
);
});
};
/**
* 连接 Dva model
*/
const ConnectedComponent = connect(
({ supplierTaskManage }: { supplierTaskManage: SupplierTaskModelState }) => ({
supplierTaskManage,
}),
)(DivisionStepComponent);
/**
* 外层转发 ref 到 innerRef
*/
const DivisionStep = forwardRef((props: any, ref) => (
<ConnectedComponent {...props} innerRef={ref} />
));
export default DivisionStep;

View File

@ -52,7 +52,7 @@ const SupplierTable: React.FC<SupplierTableProps> = ({
key: 'socialCreditCode',
},
{
title: '品类',
title: '准入品类',
dataIndex: 'categoryName',
key: 'categoryName',
render: (categoryName: string) => (

View File

@ -9,19 +9,41 @@ import {
} from './EvaluatorComponents';
import { ModalMode } from '@/servers/types/evaluator';
import type { PersonnelItem, SupplierItem } from '@/servers/types/evaluator';
import type { DeptWeightItem,TaskAddRequest } from '@/servers/types/supplierEvaluateTask';
import type { DeptWeightItem } from '@/servers/dao/supplierEvaluateTask';
import type { Dispatch } from 'umi';
import { connect } from 'umi';
import type { SupplierTaskModelState } from '@/models/supplierTaskManage';
/**
* 组件接收的Props接口
* supplierTaskManage: Dva model 状态
* dispatch: Dva 的 dispatch 函数,用于触发 action
* innerRef: 内部 ref 用于暴露方法给父组件
*/
interface EvaluatorSelectStepProps {
formData: Partial<TaskAddRequest>; // 从上层组件传递过来的表单数据
onFormDataChange: (data: Partial<TaskAddRequest>) => void; // 表单数据变更回调函数
supplierTaskManage: SupplierTaskModelState;
dispatch: Dispatch;
innerRef?: any; // 使用 innerRef 作为属性名
}
const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
({ formData, onFormDataChange }, ref) => {
/**
* 评价人员选择步骤组件
* 主要功能:选择供应商评价人员,设置评分单位权重
* 数据流转:
* 1. 从上一步获取供应商数据(通过 model.taskFormData
* 2. 组织评价人员列表并维护到本地状态
* 3. 通过 dispatch 将更新的数据同步回 model
*/
const EvaluatorSelectStepComponent = (props: EvaluatorSelectStepProps) => {
const { supplierTaskManage, dispatch, innerRef } = props;
// 从 model 获取表单数据,避免通过 props 层层传递
const { taskFormData } = supplierTaskManage;
// 选中的供应商行的key列表用于批量操作
const [selectedRowKeys, setSelectedRowKeys] = useState<React.Key[]>([]);
// 供应商列表数据,包含评价人员信息
// 供应商列表数据,包含评价人员信息从Dva model获取初始数据维护在本地状态
const [suppliers, setSuppliers] = useState<SupplierItem[]>([]);
// 批量选择模态框的可见性控制
@ -45,8 +67,11 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
// 表单实例,用于权重设置
const [form] = Form.useForm();
// 暴露表单方法给父组件
useImperativeHandle(ref, () => ({
/**
* 暴露表单方法给父组件
* 包含验证、获取和设置表单数据的方法
*/
useImperativeHandle(innerRef, () => ({
validateFields: () => {
// 自定义验证逻辑
if (suppliers.length === 0) {
@ -64,6 +89,8 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
return Promise.resolve();
},
// 获取表单数据的方法,返回处理后的数据结构
getFieldsValue: () => {
// 构建评价人员列表
const indicatorList = suppliers.flatMap(
@ -81,6 +108,7 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
userIds: supplier.evaluators?.map((e: PersonnelItem) => e.id) || [],
}));
// 返回完整的表单数据
return {
indicatorList,
supplierIds,
@ -88,6 +116,8 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
taskDeptWeightList,
};
},
// 设置表单数据的方法,通常在编辑模式下使用
setFieldsValue: (values: any) => {
if (values.suppliersWithEvaluators) {
setSuppliers(values.suppliersWithEvaluators);
@ -98,21 +128,28 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
},
}));
// 从上一步获取供应商数据
/**
* 从上一步获取供应商数据
* 使用 useEffect 监听 taskFormData 变化,确保任何来自 model 的数据变更都能被捕获
*/
useEffect(() => {
console.log(formData.selectedSuppliers)
if (formData.selectedSuppliers && formData.selectedSuppliers.length > 0) {
// 从Dva model中获取上一步选择的供应商数据
if (taskFormData.selectedSuppliers && taskFormData.selectedSuppliers.length > 0) {
// 转换上一步的供应商数据,添加评价人员数量字段
const suppliersWithEvaluators = formData.selectedSuppliers.map((supplier: SupplierItem) => {
const suppliersWithEvaluators = taskFormData.selectedSuppliers.map(
(supplier: SupplierItem) => {
// 确保evaluators字段存在且为数组
const evaluators = supplier.evaluators || [];
return {
...supplier,
userDept: supplier.userDept || '采购部', // 假设部门数据,实际应该从上一步获取
userDept: supplier.userDept || '采购部', // 设置默认部门
evaluatorCount: evaluators.length,
evaluators: evaluators,
};
});
},
);
// 更新本地供应商状态
setSuppliers(suppliersWithEvaluators);
} else {
// 没有选择供应商,清空供应商列表
@ -120,17 +157,20 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
}
// 初始化权重数据(如果有)
if (formData.taskDeptWeightList && formData.taskDeptWeightList.length > 0) {
setTaskDeptWeightList(formData.taskDeptWeightList);
if (taskFormData.taskDeptWeightList && taskFormData.taskDeptWeightList.length > 0) {
setTaskDeptWeightList(taskFormData.taskDeptWeightList);
} else {
// 没有权重数据将在下面的useEffect中根据人员部门计算
setTaskDeptWeightList([]);
}
}, [formData]);
}, [taskFormData]); // 依赖于 taskFormData当 model 数据变化时重新计算
// 当选择的人员变化时,更新权重单位列表
/**
* 当选择的人员变化时,更新权重单位列表
* 根据所有评价人员的部门信息,动态生成权重单位列表
*/
useEffect(() => {
// 抽取所有评价人员的部门
// 从所有供应商的评价人员中提取部门信息
const allDepartments: PersonnelItem[] = [];
suppliers.forEach((supplier) => {
@ -145,7 +185,7 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
// 去重部门列表 - 根据部门ID去重
const departmentMap = new Map<string, PersonnelItem>();
allDepartments.forEach(dept => {
allDepartments.forEach((dept) => {
if (dept.userDeptId && !departmentMap.has(dept.userDeptId)) {
departmentMap.set(dept.userDeptId, dept);
}
@ -170,53 +210,67 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
}));
});
}
}, [suppliers]);
}, [suppliers]); // 依赖于suppliers当选择的供应商或其评价人员变化时重新计算
// 更新表单数据
/**
* 更新表单数据
* 将本地状态同步到 Dva model
* @param updatedData 要更新的部分数据
*/
const updateFormData = (updatedData: any) => {
// // 构建评价人员列表
const indicatorList = suppliers.flatMap(
(supplier) =>
supplier.evaluators?.map((evaluator: PersonnelItem) => ({
userId: evaluator.id,
type: 0, // 默认按评价单评价 (没有指派分工),如果指派了 (就 1 按指标)
indicatorIds: [], // 指标id集合
})) || [],
);
// 结构 更新数据中的suppliersWithEvaluators
const { suppliersWithEvaluators }: { suppliersWithEvaluators: SupplierItem[] } = updatedData;
// 构建供应商ID列表
const supplierIds = suppliers.map((supplier) => ({
const supplierIds = suppliersWithEvaluators.map((supplier) => ({
id: supplier.id,
userIds: supplier.evaluators?.map((e: PersonnelItem) => e.id) || [],
}));
// 如果有taskDeptWeightList数据直接使用
if (updatedData.taskDeptWeightList) {
onFormDataChange({
// 构建userList 并去重
const userList = Array.from(
new Map(
suppliersWithEvaluators
.flatMap(s => s.evaluators || [])
.map(user => [user.id, user])
).values()
);
// 构建评价人员列表
const indicatorList = userList.map((user) => ({
userId: user.id,
type: 0, // 默认按评价单评价 (没有指派分工),如果指派了 (就 1 按指标)
indicatorIds: [], // 指标id集合
}));
// 通过dispatch更新model中的数据
// 这是组件与Dva model交互的关键
dispatch({
type: 'supplierTaskManage/updateFormData', // action类型
payload: {
// action数据
...updatedData,
indicatorList,
userList,
supplierIds,
suppliersWithEvaluators: suppliersWithEvaluators,
},
});
} else {
// 否则包含当前的taskDeptWeightList
onFormDataChange({
...updatedData,
indicatorList,
supplierIds,
taskDeptWeightList,
});
}
};
// 处理批量选择
/**
* 处理批量选择按钮点击事件
* 打开批量选择评价人员模态框
*/
const handleBatchSelect = () => {
if (selectedRowKeys.length === 0) return;
setBatchSelectModalVisible(true);
};
// 处理设置评分单位权重
/**
* 处理设置评分单位权重按钮点击事件
* 打开权重设置模态框
*/
const handleWeightSetting = () => {
// 设置初始表单
// 将权重数据转换为表单初始
form.setFieldsValue({
taskDeptWeightList: taskDeptWeightList.reduce((acc, item) => {
acc[item.weightDept] = parseInt(item.weightValue, 10) || 0;
@ -227,16 +281,22 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
setWeightSettingModalVisible(true);
};
// 保存权重设置
/**
* 保存权重设置
* 更新本地权重数据并同步到 Dva model
*/
const handleSaveWeights = () => {
form.validateFields().then((values) => {
// 将表单值转换回权重列表格式
const updatedTaskDeptWeightList = taskDeptWeightList.map((item) => ({
...item,
weightValue: values.taskDeptWeightList[item.weightDept].toString(),
}));
// 更新本地状态
setTaskDeptWeightList(updatedTaskDeptWeightList);
// 同步到Dva model
updateFormData({
suppliersWithEvaluators: suppliers,
taskDeptWeightList: updatedTaskDeptWeightList,
@ -246,14 +306,22 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
});
};
// 处理选择评价人员
/**
* 处理选择评价人员按钮点击事件
* 打开评价人员选择模态框
* @param supplier 当前选中的供应商
*/
const handleSelectEvaluators = (supplier: SupplierItem) => {
setCurrentSupplier(supplier);
setModalMode(ModalMode.SELECT);
setEvaluatorModalVisible(true);
};
// 处理查看评价人员
/**
* 处理查看评价人员按钮点击事件
* 打开评价人员查看模态框
* @param supplier 当前选中的供应商
*/
const handleViewEvaluators = (supplier: SupplierItem) => {
// 查找完整的供应商数据包括evaluators
const fullSupplier = suppliers.find((s) => s.id === supplier.id);
@ -267,10 +335,15 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
setEvaluatorModalVisible(true);
};
// 处理评价人员选择确认
/**
* 处理评价人员选择确认
* 更新供应商的评价人员列表并同步到 Dva model
* @param selectedEvaluators 选中的评价人员列表
*/
const handleEvaluatorSelect = (selectedEvaluators: PersonnelItem[]) => {
if (!currentSupplier) return;
// 更新当前供应商的评价人员列表
const updatedSuppliers = suppliers.map((supplier) => {
if (supplier.id === currentSupplier.id) {
const updated = {
@ -283,14 +356,25 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
return supplier;
});
// 更新本地状态
setSuppliers(updatedSuppliers);
// 同步到Dva model
updateFormData({ suppliersWithEvaluators: updatedSuppliers });
// 关闭模态框
setEvaluatorModalVisible(false);
};
// 处理批量选择评价人员确认
/**
* 处理批量选择评价人员确认
* 批量更新供应商的评价人员列表并同步到 Dva model
* @param selectedEvaluators 选中的评价人员列表
*/
const handleBatchEvaluatorSelect = (selectedEvaluators: PersonnelItem[]) => {
if (selectedRowKeys.length === 0) return;
// 更新所有选中供应商的评价人员列表
const updatedSuppliers = suppliers.map((supplier) => {
if (selectedRowKeys.includes(supplier.id)) {
return {
@ -301,23 +385,41 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
}
return supplier;
});
// 更新本地状态
setSuppliers(updatedSuppliers);
// 同步到Dva model
updateFormData({ suppliersWithEvaluators: updatedSuppliers });
// 关闭模态框
setBatchSelectModalVisible(false);
};
// 处理删除供应商
/**
* 处理删除供应商
* 从供应商列表中删除指定供应商并同步到 Dva model
* @param key 供应商ID
*/
const handleDeleteSupplier = (key: string) => {
// 过滤掉要删除的供应商
const updatedSuppliers = suppliers.filter((item) => item.id !== key);
// 更新本地状态
setSuppliers(updatedSuppliers);
// 同步到Dva model
updateFormData({ suppliersWithEvaluators: updatedSuppliers });
// 更新选中行,移除已删除的供应商
setSelectedRowKeys((prevKeys) => prevKeys.filter((k) => k !== key));
};
// 渲染组件
return (
<div className={styles.evaluatorSelectStep}>
<Card title="选择评价人员" bordered={false} className="inner-card">
{/* 工具栏区域 */}
<div className={styles.toolbar}>
<Space>
<Button
@ -333,6 +435,7 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
</Space>
</div>
{/* 供应商表格区域 */}
{suppliers.length === 0 ? (
<div style={{ textAlign: 'center', padding: '30px 0', color: '#999' }}>
@ -375,7 +478,23 @@ const EvaluatorSelectStep = forwardRef<any, EvaluatorSelectStepProps>(
</Card>
</div>
);
},
);
};
/**
* 连接 Dva model
* 将 model 中的状态映射到组件 props
*/
const ConnectedComponent = connect(
({ supplierTaskManage }: { supplierTaskManage: SupplierTaskModelState }) => ({
supplierTaskManage,
}),
)(EvaluatorSelectStepComponent);
/**
* 外层转发 ref 到 innerRef
*/
const EvaluatorSelectStep = forwardRef((props: any, ref) => (
<ConnectedComponent {...props} innerRef={ref} />
));
export default EvaluatorSelectStep;

View File

@ -1,27 +1,37 @@
import React, { forwardRef, useImperativeHandle, useEffect, useState } from 'react';
import { Card, Form } from 'antd';
import { Card } from 'antd';
import styles from '../supplierTaskManageAdd.less';
import SupplierSelector from '@/components/SupplierSelector';
import type { TaskAddRequest,SupplierItem } from '@/servers/types/supplierEvaluateTask';
import type { SupplierItem } from '@/servers/dao/supplierEvaluateTask';
import type { Dispatch } from 'umi';
import { connect } from 'umi';
import type { SupplierTaskModelState } from '@/models/supplierTaskManage';
interface SupplierSelectStepProps {
formData: Partial<TaskAddRequest>; // 从父组件传递的表单数据
onFormDataChange: (data: Partial<TaskAddRequest>) => void; // 表单数据变更的回调函数
supplierTaskManage: SupplierTaskModelState;
dispatch: Dispatch;
innerRef?: any; // 使用 innerRef 作为属性名
}
const SupplierSelectStep = forwardRef<any, SupplierSelectStepProps>(({ formData, onFormDataChange }, ref) => {
// 定义组件,使用 innerRef 代替直接的 ref
const SupplierSelectStepComponent = (props: SupplierSelectStepProps) => {
const { supplierTaskManage, dispatch, innerRef } = props;
// 从model获取数据
const { taskFormData } = supplierTaskManage;
// 内部状态避免直接操作formData导致循环更新
const [selectedSuppliers, setSelectedSuppliers] = useState<SupplierItem[]>([]);
// 当formData.selectedSuppliers更新时同步到本地状态
// 当taskFormData.selectedSuppliers更新时同步到本地状态
useEffect(() => {
if (formData.selectedSuppliers && formData.selectedSuppliers.length > 0) {
setSelectedSuppliers(formData.selectedSuppliers);
if (taskFormData.selectedSuppliers && taskFormData.selectedSuppliers.length > 0) {
setSelectedSuppliers(taskFormData.selectedSuppliers);
}
}, [formData.selectedSuppliers]); // 只在表单ID变化时更新编辑模式加载时
}, [taskFormData.selectedSuppliers]); // 只在表单ID变化时更新编辑模式加载时
// 暴露表单方法给父组件
useImperativeHandle(ref, () => ({
// 暴露表单方法给父组件,使用 innerRef
useImperativeHandle(innerRef, () => ({
validateFields: () => {
// 这里可以添加自定义验证逻辑
return Promise.resolve();
@ -51,10 +61,13 @@ const SupplierSelectStep = forwardRef<any, SupplierSelectStepProps>(({ formData,
// 更新本地状态
setSelectedSuppliers(suppliersWithEvaluators);
// 通知父组件
onFormDataChange({
// 通过dispatch更新model数据
dispatch({
type: 'supplierTaskManage/updateFormData',
payload: {
selectedSuppliers: suppliersWithEvaluators,
supplierIds: suppliersWithEvaluators.map(supplier => ({ id: supplier.id }))
}
});
};
@ -68,6 +81,18 @@ const SupplierSelectStep = forwardRef<any, SupplierSelectStepProps>(({ formData,
</Card>
</div>
);
});
};
// 连接 Dva model
const ConnectedComponent = connect(
({ supplierTaskManage }: { supplierTaskManage: SupplierTaskModelState }) => ({
supplierTaskManage,
})
)(SupplierSelectStepComponent);
// 外层转发 ref 到 innerRef
const SupplierSelectStep = forwardRef((props: any, ref) => (
<ConnectedComponent {...props} innerRef={ref} />
));
export default SupplierSelectStep;

View File

@ -1,23 +1,22 @@
import React, { useState, useRef, useEffect } from 'react';
import { Card, Steps, Button, message, Space, Row, Col, Form, Modal } from 'antd';
import { history } from 'umi';
import React, { useRef, useEffect } from 'react';
import { Card, Steps, Button, message, Space, Row, Col, Modal } from 'antd';
import { connect, ConnectProps, history, Dispatch } from 'umi';
import { ArrowLeftOutlined, SaveOutlined } from '@ant-design/icons';
import { addTask, getTaskDetail, updateTask } from '@/servers/api/supplierEvaluate';
import BasicInfoStep from './components/BasicInfoStep';
import SupplierSelectStep from './components/SupplierSelectStep';
import EvaluatorSelectStep from './components/EvaluatorSelectStep';
import DivisionStep from './components/DivisionStep';
import styles from './supplierTaskManageAdd.less';
import type {
DeptWeightItem,
TaskAddRequest,
TaskDetailData,
} from '@/servers/types/supplierEvaluateTask';
import { TaskNotifyLowerUnits } from '@/dicts/supplierTaskDict';
import { SupplierTaskModelState } from '@/models/supplierTaskManage';
const { Step } = Steps;
// 获取URL参数
/**
* 获取URL参数
* 解析URL中的id和mode参数用于判断是否为编辑模式
* @returns {object} 包含id和mode的对象
*/
const getUrlParams = () => {
const location = window.location.href;
const url = new URL(location);
@ -27,143 +26,63 @@ const getUrlParams = () => {
};
};
const SupplierTaskManageAdd: React.FC = () => {
// 当前步骤索引从0开始
const [currentStep, setCurrentStep] = useState<number>(0);
/**
* 页面组件Props接口定义
* 继承了ConnectProps添加了supplierTaskManage和dispatch
*/
interface PageProps extends ConnectProps {
supplierTaskManage: SupplierTaskModelState; // dva model状态
dispatch: Dispatch; // dva dispatch方法
}
// 提交加载状态
const [loading, setLoading] = useState<boolean>(false);
/**
* 供应商任务管理添加/编辑组件
* 使用步骤式表单引导用户完成添加或编辑任务的流程
*/
const SupplierTaskManageAdd: React.FC<PageProps> = ({ supplierTaskManage, dispatch }) => {
// 获取dva model中的状态
const { currentStep, loading, detailLoading } = supplierTaskManage;
// 判断是否为编辑模式
const urlParams = getUrlParams();
const isEditMode = urlParams.mode === 'edit' && urlParams.id;
const taskId = urlParams.id || '';
// 整个表单的数据,包含所有步骤的数据
const [formData, setFormData] = useState<Partial<TaskAddRequest>>({});
// 加载状态
const [detailLoading, setDetailLoading] = useState<boolean>(false);
// 创建表单引用,用于访问子组件的表单方法(仅用于验证)
// 创建表单引用,用于访问子组件的表单方法(主要用于验证)
const basicFormRef = useRef<any>(null); // 基本信息表单引用
const supplierFormRef = useRef<any>(null); // 供应商选择表单引用
const evaluatorFormRef = useRef<any>(null); // 评价人员表单引用
const divisionFormRef = useRef<any>(null); // 评价分工表单引用
// 确认对话框可见性状态
const [confirmModalVisible, setConfirmModalVisible] = useState(false);
const [confirmModalVisible, setConfirmModalVisible] = React.useState(false);
// 获取任务详情
const fetchTaskDetail = async (id: string) => {
setDetailLoading(true);
try {
const response = await getTaskDetail(id);
if (response.success) {
const detail: TaskDetailData = response.data;
// 转换任务详情数据为表单数据结构
const taskFormData: Partial<TaskAddRequest> = {
id: detail.id || '',
evaluateTheme: detail.evaluateTheme || '',
startTime: detail.startTime || '',
endTime: detail.endTime || '',
templateId: detail.templateId || '',
categoryLimitation: detail.categoryLimitation || '0',
evaluateYear: detail.evaluateYear || '',
categoryId: detail.categoryId || undefined,
// 供应商数据回显转换
selectedSuppliers: detail.blackSupplierVos.map((item) => ({
...item,
id: item.supplierId,
name: item.supplierName,
evaluators: item.userList,
})),
// 接口返回的人员分配的指标,以人员userId 为维度 indicatorIds[string] 指标id
indicatorList: detail.indicatorList || [],
// 后台用供应商集合,包含供应商id 并且关联 userIds
supplierIds: detail.supplierIds || [],
// 部门权重设置
taskDeptWeightList: detail.taskDeptWeightList || [],
// 分配指标分工回显
suppliersWithEvaluators: detail.blackSupplierVos.map((item) => ({
...item,
id: item.supplierId,
name: item.supplierName,
evaluators: item.userList,
})),
};
// 更新表单数据 - 子组件通过props获取
setFormData(taskFormData);
} else {
message.error(response.message || '获取任务详情失败');
}
} catch (error) {
console.error('获取任务详情失败:', error);
message.error('获取任务详情失败');
} finally {
setDetailLoading(false);
}
};
// 编辑模式下获取任务详情
/**
* 编辑模式下获取任务详情,或新建模式下重置状态
* 利用useEffect在组件挂载或依赖项变化时触发
*/
useEffect(() => {
if (isEditMode) {
fetchTaskDetail(taskId);
if (isEditMode && taskId && dispatch) {
// 编辑模式,获取任务详情
dispatch({
type: 'supplierTaskManage/fetchTaskDetail',
payload: { taskId },
});
} else if (dispatch) {
// 新建模式,重置状态
dispatch({
type: 'supplierTaskManage/resetState',
});
}
}, [isEditMode, taskId]);
}, [isEditMode, taskId, dispatch]);
// 处理表单数据变更
const handleFormDataChange = (data: Partial<TaskAddRequest>) => {
// 第一步:基本信息
if (data) {
setFormData((prev) => ({ ...prev, ...data }));
}
// 第二步:供应商选择
if (data.selectedSuppliers) {
// 确保供应商数据包含evaluators字段
const suppliersWithEvaluators = data.selectedSuppliers.map((supplier: any) => ({
...supplier,
evaluators: supplier.evaluators || [], // 确保evaluators字段存在
}));
setFormData((prev) => ({ ...prev, selectedSuppliers: suppliersWithEvaluators }));
}
// 第三步:评价人员
if (data.suppliersWithEvaluators) {
// 确保suppliersWithEvaluators和selectedSuppliers保持一致
const evaluatedSuppliers = data.suppliersWithEvaluators;
setFormData((prev) => ({
...prev,
suppliersWithEvaluators: evaluatedSuppliers,
selectedSuppliers: evaluatedSuppliers, // 同步更新selectedSuppliers
}));
}
// 处理部门权重列表 taskDeptWeightList
if (data.taskDeptWeightList) {
setFormData((prev) => ({
...prev,
taskDeptWeightList: data.taskDeptWeightList,
}));
}
};
// 步骤配置
// 步骤配置,定义每个步骤的标题、描述和内容组件
const steps = [
{
title: '基本信息', // 步骤标题
description: '请填写基本信息', // 步骤描述
content: (
<BasicInfoStep
formData={formData}
onFormDataChange={handleFormDataChange}
ref={basicFormRef}
/>
), // 步骤内容组件
@ -173,8 +92,6 @@ const SupplierTaskManageAdd: React.FC = () => {
description: '请选择参加评价的供应商',
content: (
<SupplierSelectStep
formData={formData}
onFormDataChange={handleFormDataChange}
ref={supplierFormRef}
/>
),
@ -184,8 +101,6 @@ const SupplierTaskManageAdd: React.FC = () => {
description: '请选择供应商评价人员',
content: (
<EvaluatorSelectStep
formData={formData}
onFormDataChange={handleFormDataChange}
ref={evaluatorFormRef}
/>
),
@ -195,23 +110,27 @@ const SupplierTaskManageAdd: React.FC = () => {
description: '不设置按默认全部指标评价',
content: (
<DivisionStep
formData={formData}
onFormDataChange={handleFormDataChange}
ref={divisionFormRef}
/>
),
},
];
// 处理返回
/**
* 处理返回按钮点击事件
* 返回上一页
*/
const handleBack = () => {
history.goBack();
};
// 下一步
/**
* 处理下一步按钮点击事件
* 验证当前步骤的表单数据,通过后进入下一步
*/
const handleNext = async () => {
try {
// 验证当前步骤表单
// 根据当前步骤验证相应的表单
if (currentStep === 0 && basicFormRef.current) {
// 验证基本信息
await basicFormRef.current.validateFields();
@ -231,7 +150,9 @@ const SupplierTaskManageAdd: React.FC = () => {
}
// 验证通过,进入下一步
setCurrentStep(currentStep + 1);
if (dispatch) {
dispatch({ type: 'supplierTaskManage/nextStep' });
}
} catch (errorInfo: any) {
// 表单验证失败
console.log('表单验证失败:', errorInfo);
@ -243,83 +164,40 @@ const SupplierTaskManageAdd: React.FC = () => {
}
};
// 上一步
/**
* 处理上一步按钮点击事件
* 返回上一个步骤
*/
const handlePrev = () => {
setCurrentStep(currentStep - 1);
};
// 实际提交数据的函数
const submitTaskData = async (taskStatus: TaskNotifyLowerUnits) => {
setLoading(true);
try {
// 构建提交数据,确保必填字段有值
const submitData = {
evaluateTheme: formData.evaluateTheme || '', // 评价主题
startTime: formData.startTime || '', // 开始时间
endTime: formData.endTime || '', // 结束时间
templateId: formData.templateId || '', // 模板ID
categoryLimitation: formData.categoryLimitation || '0', // 品类限制
evaluateYear: formData.evaluateYear || '', // 评价年份
categoryId: formData.categoryId || '', // 品类ID
taskStatus: taskStatus, // 任务状态,根据用户的选择决定
// 供应商ID列表包含评价人员ID
supplierIds:
formData.selectedSuppliers?.map((supplier: any) => {
// 从供应商的evaluators中提取用户ID
const userIds = supplier.evaluators?.map((evaluator: any) => evaluator.id) || [];
return {
id: supplier.id,
userIds,
};
}) || [],
// 评价指标列表
indicatorList:
formData.indicatorList?.map((item: any) => ({
userId: item.userId,
// 评价类型如果用户关联了指标则为1(按指标)否则为0(按评价单)
type: item.indicatorIds && item.indicatorIds.length > 0 ? 1 : 0,
indicatorIds: item.indicatorIds || [],
})) || [],
// 部门权重列表过滤掉权重为0的
taskDeptWeightList:
formData.taskDeptWeightList?.filter((item: any) => {
return item.weightValue && item.weightValue !== '0';
}) || [],
};
let response;
if (isEditMode) {
// 编辑模式添加ID字段
const updateData = {
...submitData,
id: taskId,
};
response = await updateTask(updateData);
} else {
// 新增模式
response = await addTask(submitData);
}
if (response.success) {
message.success(isEditMode ? '任务更新成功' : '任务创建成功');
// 成功后直接返回列表页面
history.push('/supplier/supplierTaskManage');
} else {
message.error(response.message || '提交失败');
}
} catch (error) {
console.error('提交失败:', error);
message.error('提交失败');
} finally {
setLoading(false);
if (dispatch) {
dispatch({ type: 'supplierTaskManage/prevStep' });
}
};
// 提交表单
/**
* 提交任务数据
* @param taskStatus 任务状态,决定是否需要下级单位完善
*/
const submitTaskData = (taskStatus: TaskNotifyLowerUnits | null) => {
if (dispatch) {
dispatch({
type: 'supplierTaskManage/submitTaskData',
payload: {
taskStatus,
isEditMode,
taskId,
onSuccess: () => {
history.goBack();
}
},
});
}
};
/**
* 处理提交按钮点击事件
* 验证评价分工表单,通过后根据是否为编辑模式决定提交方式
*/
const handleSubmit = async () => {
// 验证评价分工
if (divisionFormRef.current) {
@ -329,23 +207,42 @@ const SupplierTaskManageAdd: React.FC = () => {
return;
}
}
// 如果是编辑模式,则直接提交 提示是否确认后直接提交
if (isEditMode) {
Modal.confirm({
title: '提示',
content: '是否确认提交',
onOk: () => {
submitTaskData(null);
},
});
return;
}
// 显示确认对话框
// 新增模式下,显示确认对话框询问是否需要下级单位完善
setConfirmModalVisible(true);
};
// 处理确认对话框的取消
/**
* 处理确认对话框的取消按钮点击事件
*/
const handleConfirmCancel = () => {
setConfirmModalVisible(false);
};
// 处理确认对话框的"是"选项
/**
* 处理确认对话框的"是"选项点击事件
* 提交任务,并设置状态为需要下级单位完善
*/
const handleConfirmYes = () => {
submitTaskData(TaskNotifyLowerUnits.YES); // 未开始状态,需要下级单位完善
setConfirmModalVisible(false);
};
// 处理确认对话框的"否"选项
/**
* 处理确认对话框的"否"选项点击事件
* 提交任务,并设置状态为不需要下级单位完善
*/
const handleConfirmNo = () => {
submitTaskData(TaskNotifyLowerUnits.NO); // 进行中状态,不需要下级单位完善
setConfirmModalVisible(false);
@ -353,7 +250,9 @@ const SupplierTaskManageAdd: React.FC = () => {
return (
<div className="common-container">
{/* 卡片容器,显示加载状态 */}
<Card bordered={false} loading={detailLoading}>
{/* 页面头部,包含标题和返回按钮 */}
<div className="page-header">
<h2>{isEditMode ? '修改评价任务' : '新增评价任务'}</h2>
<Button type="link" icon={<ArrowLeftOutlined />} onClick={handleBack}>
@ -361,7 +260,9 @@ const SupplierTaskManageAdd: React.FC = () => {
</Button>
</div>
{/* 步骤式表单布局 */}
<Row gutter={24} className={styles.stepsLayout}>
{/* 左侧步骤导航 */}
<Col span={6} className={styles.stepsLeft}>
<Steps direction="vertical" current={currentStep} className={styles.verticalSteps}>
{steps.map((item) => (
@ -369,9 +270,11 @@ const SupplierTaskManageAdd: React.FC = () => {
))}
</Steps>
</Col>
{/* 右侧表单内容 */}
<Col span={18} className={styles.stepsRight}>
<div className={styles.stepsContent}>{steps[currentStep].content}</div>
{/* 步骤操作按钮 */}
<div className={styles.stepsAction}>
<Space>
{currentStep > 0 && <Button onClick={handlePrev}></Button>}
@ -396,7 +299,7 @@ const SupplierTaskManageAdd: React.FC = () => {
</Row>
</Card>
{/* 确认对话框 */}
{/* 确认对话框 - 询问是否需要下级单位完善 */}
<Modal
title="提交确认"
visible={confirmModalVisible}
@ -418,4 +321,7 @@ const SupplierTaskManageAdd: React.FC = () => {
);
};
export default SupplierTaskManageAdd;
// 将dva model中的状态映射到组件props
export default connect(({ supplierTaskManage }: { supplierTaskManage: SupplierTaskModelState }) => ({
supplierTaskManage,
}))(SupplierTaskManageAdd);

View File

@ -1,5 +1,26 @@
import request from '@/utils/request';
import type { TaskDetailResponse } from '@/servers/types/supplierEvaluateTask';
import type {
TaskDetailResponse,
TemplateRequest,
TemplateResponse,
TemplateDetailResponse,
TemplateAddRequest,
TemplateUpdateRequest,
CategoryTreeResponse,
TaskRequest,
TaskResponse,
EvaluateTaskRequest,
EvaluateTaskData,
EvaluateSupplierRequest,
EvaluateSupplierData,
EvaluateScoreRequest,
EvaluateScoreDetailData,
EvaluateRuleResponse,
EvaluateRuleDetailResponse,
EvaluateRuleAddRequest,
EvaluateRuleUpdateRequest,
TaskAddRequest,
} from '@/servers/dao/supplierEvaluateTask';
/**
* 获取所有模板列表
@ -16,8 +37,8 @@ export async function getAllTemplates() {
* @param params 查询参数
* @returns Promise
*/
export async function getTemplateList(params: SupplierEvaluate.TemplateRequest) {
return request<SupplierEvaluate.TemplateResponse>('/coscoEvaluate/template/getPage', {
export async function getTemplateList(params: TemplateRequest) {
return request<TemplateResponse>('/coscoEvaluate/template/getPage', {
method: 'POST',
data: params,
});
@ -29,7 +50,7 @@ export async function getTemplateList(params: SupplierEvaluate.TemplateRequest)
* @returns Promise
*/
export async function getTemplateDetail(id: string) {
return request<SupplierEvaluate.TemplateDetailResponse>(`/coscoEvaluate/template/${id}`, {
return request<TemplateDetailResponse>(`/coscoEvaluate/template/${id}`, {
method: 'GET',
});
}
@ -39,7 +60,7 @@ export async function getTemplateDetail(id: string) {
* @param params 模板数据
* @returns Promise
*/
export async function addTemplate(params: SupplierEvaluate.TemplateAddRequest) {
export async function addTemplate(params: TemplateAddRequest) {
return request<API.APIResponse<any>>('/coscoEvaluate/template', {
method: 'POST',
data: params,
@ -52,7 +73,7 @@ export async function addTemplate(params: SupplierEvaluate.TemplateAddRequest) {
* @param params 模板数据
* @returns Promise
*/
export async function updateTemplate(params: SupplierEvaluate.TemplateUpdateRequest) {
export async function updateTemplate(params: TemplateUpdateRequest) {
return request<API.APIResponse<any>>('/coscoEvaluate/template', {
method: 'PUT',
data: params,
@ -110,7 +131,7 @@ export async function getCategoryList() {
* @returns Promise
*/
export async function getCategoryTree() {
return request<SupplierEvaluate.CategoryTreeResponse>('/cosco/category/categoryTree', {
return request<CategoryTreeResponse>('/cosco/category/categoryTree', {
method: 'GET',
});
}
@ -130,8 +151,8 @@ export async function getDepartmentList() {
* @param params 查询参数
* @returns Promise
*/
export async function getTaskList(params: SupplierEvaluate.TaskRequest) {
return request<SupplierEvaluate.TaskResponse>('/coscoEvaluate/task/getPage', {
export async function getTaskList(params: TaskRequest) {
return request<TaskResponse>('/coscoEvaluate/task/getPage', {
method: 'POST',
data: params,
});
@ -153,56 +174,21 @@ export async function getTaskDetail(id: string) {
* @param params 任务数据
* @returns Promise
*/
export async function addTask(params: SupplierEvaluate.TaskAddRequest) {
export async function addTask(params: TaskAddRequest) {
return request<API.APIResponse<any>>('/coscoEvaluate/task/addTask', {
method: 'POST',
data: params,
});
}
/**
* 更新评价任务
* @param params 任务数据
* @returns Promise
*/
export async function updateTask(params: SupplierEvaluate.TaskAddRequest) {
return request<API.APIResponse<any>>('/coscoEvaluate/task', {
method: 'PUT',
data: params,
});
}
/**
* 删除评价任务
* @param id 任务ID
* @returns Promise
*/
export async function deleteTask(id: string) {
return request<API.APIResponse<any>>('/coscoEvaluate/task/delete', {
method: 'POST',
data: { id },
});
}
/**
* 批量删除评价任务
* @param ids 任务ID数组
* @returns Promise
*/
export async function batchDeleteTask(ids: string[]) {
return request<API.APIResponse<any>>('/coscoEvaluate/task/batchDelete', {
method: 'POST',
data: { ids },
});
}
/**
* 获取评价结果列表
* @param params 查询参数
* @returns Promise
*/
export async function getEvaluateResultList(params: API.EvaluateTaskRequest) {
return request<API.APIResponse<API.EvaluateTaskData>>('/coscoEvaluate/task/getTaskPage', {
export async function getEvaluateResultList(params: EvaluateTaskRequest) {
return request<API.APIResponse<EvaluateTaskData>>('/coscoEvaluate/task/getTaskPage', {
method: 'POST',
data: params,
});
@ -213,8 +199,8 @@ export async function getEvaluateResultList(params: API.EvaluateTaskRequest) {
* @param params 查询参数
* @returns Promise
*/
export async function getEvaluateSupplierList(params: API.EvaluateSupplierRequest) {
return request<API.APIResponse<API.EvaluateSupplierData>>('/coscoEvaluate/supplier/getPage', {
export async function getEvaluateSupplierList(params: EvaluateSupplierRequest) {
return request<API.APIResponse<EvaluateSupplierData>>('/coscoEvaluate/supplier/getPage', {
method: 'POST',
data: params,
});
@ -225,7 +211,7 @@ export async function getEvaluateSupplierList(params: API.EvaluateSupplierReques
* @param params 查询参数
* @returns Promise
*/
export async function getEvaluateScoreList(params: API.EvaluateScoreRequest) {
export async function getEvaluateScoreList(params: EvaluateScoreRequest) {
return request<API.APIResponse<API.PageResponse<any>>>('/coscoEvaluate/supplier/getSupplierDimension', {
method: 'POST',
data: params,
@ -238,7 +224,7 @@ export async function getEvaluateScoreList(params: API.EvaluateScoreRequest) {
* @returns Promise
*/
export async function getEvaluateScoreDetail(id: string) {
return request<API.APIResponse<API.EvaluateScoreDetailData>>(`/coscoEvaluate/user/getIndicator?id=${id}`, {
return request<API.APIResponse<EvaluateScoreDetailData>>(`/coscoEvaluate/user/getIndicator?id=${id}`, {
method: 'GET',
});
}
@ -248,7 +234,7 @@ export async function getEvaluateScoreDetail(id: string) {
* @returns Promise
*/
export async function getAllEvaluateRules() {
return request<API.EvaluateRuleResponse>('/coscoEvaluate/level/getAllList', {
return request<EvaluateRuleResponse>('/coscoEvaluate/level/getAllList', {
method: 'GET',
});
}
@ -259,7 +245,7 @@ export async function getAllEvaluateRules() {
* @returns Promise
*/
export async function getEvaluateRuleDetail(id: string) {
return request<API.EvaluateRuleDetailResponse>(`/coscoEvaluate/level/${id}`, {
return request<EvaluateRuleDetailResponse>(`/coscoEvaluate/level/${id}`, {
method: 'GET',
});
}
@ -269,7 +255,7 @@ export async function getEvaluateRuleDetail(id: string) {
* @param params 规则数据
* @returns Promise
*/
export async function addEvaluateRule(params: API.EvaluateRuleAddRequest) {
export async function addEvaluateRule(params: EvaluateRuleAddRequest) {
return request<API.APIResponse<any>>('/coscoEvaluate/level', {
method: 'POST',
data: params,
@ -281,7 +267,7 @@ export async function addEvaluateRule(params: API.EvaluateRuleAddRequest) {
* @param params 规则数据
* @returns Promise
*/
export async function updateEvaluateRule(params: API.EvaluateRuleUpdateRequest) {
export async function updateEvaluateRule(params: EvaluateRuleUpdateRequest) {
return request<API.APIResponse<any>>('/coscoEvaluate/level', {
method: 'PUT',
data: params,
@ -305,7 +291,7 @@ export async function deleteEvaluateRule(id: string) {
* @returns Promise
*/
export async function getSupplierScoreDetail(id: string) {
return request<API.APIResponse<API.EvaluateScoreDetailData>>(`/coscoEvaluate/supplier/getScoreResult`, {
return request<API.APIResponse<EvaluateScoreDetailData>>(`/coscoEvaluate/supplier/getScoreResult`, {
method: 'GET',
params: { id }
});

View File

@ -0,0 +1,536 @@
import type { TaskNotifyLowerUnits } from '@/dicts/supplierTaskDict';
/**
* 供应商评价相关接口类型定义
*/
// 模板相关类型
/**
* 模板查询请求参数
*/
export interface TemplateRequest {
current?: number;
pageSize?: number;
templateName?: string;
status?: string;
}
/**
* 模板查询响应
*/
export interface TemplateResponse {
code: number;
success: boolean;
data: {
records: TemplateItem[];
total: number;
size: number;
current: number;
pages: number;
};
message: string;
}
/**
* 模板项
*/
export interface TemplateItem {
id: string;
templateName: string;
status: string;
createTime: string;
updateTime: string;
createBy: string;
updateBy: string;
[key: string]: any;
}
/**
* 模板详情响应
*/
export interface TemplateDetailResponse {
code: number;
success: boolean;
data: {
id: string;
templateName: string;
status: string;
dimensions: TemplateDimension[];
[key: string]: any;
};
message: string;
}
/**
* 模板维度
*/
export interface TemplateDimension {
id: string;
dimensionName: string;
dimensionWeight: number;
indicators: TemplateIndicator[];
[key: string]: any;
}
/**
* 模板指标
*/
export interface TemplateIndicator {
id: string;
indicatorName: string;
indicatorWeight: number;
[key: string]: any;
}
/**
* 新增模板请求
*/
export interface TemplateAddRequest {
templateName: string;
dimensions: {
dimensionName: string;
dimensionWeight: number;
indicators: {
indicatorName: string;
indicatorWeight: number;
}[];
}[];
}
/**
* 更新模板请求
*/
export interface TemplateUpdateRequest {
id: string;
templateName: string;
dimensions: {
id?: string;
dimensionName: string;
dimensionWeight: number;
indicators: {
id?: string;
indicatorName: string;
indicatorWeight: number;
}[];
}[];
}
// 品类相关类型
/**
* 品类树响应
*/
export interface CategoryTreeResponse {
code: number;
success: boolean;
data: CategoryTreeItem[];
message: string;
}
/**
* 品类树节点
*/
export interface CategoryTreeItem {
id: string;
name: string;
children?: CategoryTreeItem[];
[key: string]: any;
}
// 任务相关类型
/**
* 任务查询请求
*/
export interface TaskRequest {
current?: number;
pageSize?: number;
evaluateTheme?: string;
evaluateYear?: string;
startTime?: string;
endTime?: string;
categoryId?: string;
status?: string;
}
/**
* 任务查询响应
*/
export interface TaskResponse {
code: number;
success: boolean;
data: {
records: TaskItem[];
total: number;
size: number;
current: number;
pages: number;
};
message: string;
}
/**
* 任务项
*/
export interface TaskItem {
id: string;
evaluateTheme: string;
evaluateYear: string;
startTime: string;
endTime: string;
templateId: string;
templateName: string;
status: string;
categoryId?: string;
categoryName?: string;
createTime: string;
createBy: string;
[key: string]: any;
}
/*
人员信息
*/
export interface PersonnelItem {
id: string;
name: string;
position: string;
userDept: string;
userDeptId: string;
}
// 评价结果相关类型
/**
* 评价任务请求
*/
export interface EvaluateTaskRequest {
current?: number;
pageSize?: number;
evaluateTheme?: string;
evaluateYear?: string;
startTime?: string;
endTime?: string;
status?: string;
}
/**
* 评价任务数据
*/
export interface EvaluateTaskData {
records: EvaluateTaskItem[];
total: number;
size: number;
current: number;
pages: number;
}
/**
* 评价任务项
*/
export interface EvaluateTaskItem {
id: string;
evaluateTheme: string;
evaluateYear: string;
startTime: string;
endTime: string;
templateId: string;
templateName: string;
status: string;
createTime: string;
createBy: string;
supplierCount: number;
[key: string]: any;
}
/**
* 评价供应商请求
*/
export interface EvaluateSupplierRequest {
current?: number;
pageSize?: number;
taskId: string;
supplierName?: string;
status?: string;
}
/**
* 评价供应商数据
*/
export interface EvaluateSupplierData {
records: EvaluateSupplierItem[];
total: number;
size: number;
current: number;
pages: number;
}
/**
* 评价供应商项
*/
export interface EvaluateSupplierItem {
id: string;
supplierId: string;
supplierName: string;
socialCreditCode: string;
status: string;
score: number;
level: string;
[key: string]: any;
}
/**
* 评价分数请求
*/
export interface EvaluateScoreRequest {
current?: number;
pageSize?: number;
taskId: string;
supplierId: string;
}
/**
* 评价分数详情数据
*/
export interface EvaluateScoreDetailData {
id: string;
supplierId: string;
supplierName: string;
taskId: string;
evaluateTheme: string;
evaluateYear: string;
dimensions: EvaluateDimension[];
userScore: number;
totalScore: number;
level: string;
[key: string]: any;
}
/**
* 评价维度
*/
export interface EvaluateDimension {
id: string;
dimensionName: string;
dimensionWeight: number;
dimensionScore: number;
indicators: EvaluateIndicator[];
[key: string]: any;
}
/**
* 评价指标
*/
export interface EvaluateIndicator {
id: string;
indicatorName: string;
indicatorWeight: number;
score: number;
remarks: string;
[key: string]: any;
}
// 评价规则相关类型
/**
* 评价规则响应
*/
export interface EvaluateRuleResponse {
code: number;
success: boolean;
data: EvaluateRuleItem[];
message: string;
}
/**
* 评价规则项
*/
export interface EvaluateRuleItem {
id: string;
levelName: string;
minScore: number;
maxScore: number;
status: string;
createTime: string;
updateTime: string;
createBy: string;
updateBy: string;
[key: string]: any;
}
/**
* 评价规则详情响应
*/
export interface EvaluateRuleDetailResponse {
code: number;
success: boolean;
data: EvaluateRuleItem;
message: string;
}
/**
* 评价规则新增请求
*/
export interface EvaluateRuleAddRequest {
levelName: string;
minScore: number;
maxScore: number;
}
/**
* 评价规则更新请求
*/
export interface EvaluateRuleUpdateRequest {
id: string;
levelName: string;
minScore: number;
maxScore: number;
}
/**
* 供应商评价任务详情接口类型定义
*/
export interface IndicatorList {
indicatorIds: string[];
type: number;
userId: string;
}
export interface User {
userId: string;
userName: string;
userDept: string;
userDeptId: string;
}
/**
* 任务详情数据
*/
export interface TaskDetailData {
categoryId: string | null;
categoryLimitation: string | null;
createBy: string | null;
createDate: string | null;
createTime: string | null;
deleteFlag: string | null;
delFlag: string;
deptId: string | null;
endTime: string | null;
evaluateTheme: string | null;
evaluateYear: string | null;
id: string | null;
indicatorList: IndicatorList[] | null;
lastUpdateTime: string | null;
startTime: string | null;
status: string;
supplierIds: {
id: string;
userIds: string[];
}[] | null;
userList: User[];
suppliers: {
id: string;
supplierName: string;
socialCreditCode?: string;
category?: string;
department?: string;
evaluators: {
id: string;
name: string;
department: string;
position?: string;
}[];
[key: string]: any;
}[] | null;
templateId: string | null;
tenantId: string | null;
tenantName: string | null;
updateBy: string | null;
updateDate: string | null;
updateTime: string | null;
weightDept: string | null;
weightStatus: number | null;
weightValue: string | null;
taskDeptWeightList: DeptWeightItem[] | null;
blackSupplierVos: {
deptName: string;
supplierId: string;
supplierName: string;
userList: User[];
}[],
[property: string]: any;
}
// 部门配置权重
export interface DeptWeightItem {
//部门id
weightDept: string;
// 部门权重值
weightValue: string;
// 部门名称
weightDeptName: string;
}
/**
* 任务详情响应
*/
export interface TaskDetailResponse {
code: number;
data: TaskDetailData;
message: string;
success: boolean;
[property: string]: any;
}
// 新增评价任务和修改 请求参数定义
export type TaskAddRequest = {
/**
* 品类限制类型0.通用不限品类、1.限制品类)
*/
categoryLimitation?: string;
/**
* 评价结束时间
*/
endTime: string;
/**
* 评价主题
*/
evaluateTheme: string;
/**
* 评价年度
*/
evaluateYear: string;
indicatorList: IndicatorList[];
/**
* 评价开始时间
*/
startTime: string;
supplierIds: SupplierId[];
taskDeptWeightList: DeptWeightItem[];
/**
* 评价表模板id(cosco_evaluate_template表主键)
*/
templateId: string;
// 品类id
categoryId?: string;
/**
* 是否下级部门可以添加评价信息 0否1是
*/
taskStatus?: TaskNotifyLowerUnits | null;
[property: string]: any;
}
/**
* 供应商项
*/
export interface SupplierItem {
id: string; // 供应商ID
supplierName: string; // 供应商名称
socialCreditCode?: string; // 统一社会信用代码
category?: string; // 品类
department?: string; // 准入部门
evaluatorCount: number; // 评价人员数量
evaluators: User[]; // 评价人员列表
// 其他可能的字段
[key: string]: any;
}
export type SupplierId = {
/**
* 供应商id
*/
id: string;
/**
* 用户集合
*/
userIds?: string[];
}

View File

@ -13,8 +13,8 @@ export interface PersonnelItem {
userDeptId: string; // 所属部门ID
position?: string; // 职位(可选)
selected?: boolean; // 是否被选中用于UI显示
indicatorIds?: string[]; // 指标ID列表
// 其他可能的API字段
[key: string]: any;
}
/**

View File

@ -1,148 +0,0 @@
/**
* 供应商评价任务详情接口类型定义
*/
export interface IndicatorList {
indicatorIds: string[];
type: number;
userId: string;
}
export interface User{
userId: string;
userName: string;
userDept: string;
userDeptId: string;
}
/**
* 任务详情数据
*/
export interface TaskDetailData {
categoryId: string | null;
categoryLimitation: string | null;
createBy: string | null;
createDate: string | null;
createTime: string | null;
deleteFlag: string | null;
delFlag: string;
deptId: string | null;
endTime: string | null;
evaluateTheme: string | null;
evaluateYear: string | null;
id: string | null;
indicatorList: IndicatorList[] | null;
lastUpdateTime: string | null;
startTime: string | null;
status: string;
supplierIds: {
id: string;
userIds: string[];
}[] | null;
userList: User[];
suppliers: {
id: string;
supplierName: string;
socialCreditCode?: string;
category?: string;
department?: string;
evaluators: {
id: string;
name: string;
department: string;
position?: string;
}[];
[key: string]: any;
}[] | null;
templateId: string | null;
tenantId: string | null;
tenantName: string | null;
updateBy: string | null;
updateDate: string | null;
updateTime: string | null;
weightDept: string | null;
weightStatus: number | null;
weightValue: string | null;
taskDeptWeightList: DeptWeightItem[] | null;
blackSupplierVos: {
deptName: string;
supplierId: string;
supplierName: string;
userList: User[];
}[],
[property: string]: any;
}
// 部门配置权重
export interface DeptWeightItem {
//部门id
weightDept: string;
// 部门权重值
weightValue: string;
// 部门名称
weightDeptName: string;
}
/**
* 任务详情响应
*/
export interface TaskDetailResponse {
code: number;
data: TaskDetailData;
message: string;
success: boolean;
[property: string]: any;
}
// 新增评价任务和修改 请求参数定义
export type TaskAddRequest = {
/**
* 品类限制类型0.通用不限品类、1.限制品类)
*/
categoryLimitation?: string;
/**
* 评价结束时间
*/
endTime: string;
/**
* 评价主题
*/
evaluateTheme: string;
/**
* 评价年度
*/
evaluateYear: string;
indicatorList: IndicatorList[];
/**
* 评价开始时间
*/
startTime: string;
supplierIds: SupplierId[];
taskDeptWeightList: DeptWeightItem[];
/**
* 评价表模板id(cosco_evaluate_template表主键)
*/
templateId: string;
// 品类id
categoryId?: string;
[property: string]: any;
}
/**
* 供应商项
*/
export interface SupplierItem {
id: string; // 供应商ID
supplierName: string; // 供应商名称
socialCreditCode?: string; // 统一社会信用代码
category?: string; // 品类
department?: string; // 准入部门
evaluatorCount: number; // 评价人员数量
evaluators: User[]; // 评价人员列表
// 其他可能的字段
[key: string]: any;
}
export type SupplierId = {
/**
* 供应商id
*/
id: string;
/**
* 用户集合
*/
userIds?: string[];
}

2
src/typings.d.ts vendored
View File

@ -500,7 +500,7 @@ declare namespace SupplierEvaluate {
/**
* 是否通知下级单位完善评价人及评价分工 0否1是
*/
taskStatus: number;
taskStatus: number | null;
[property: string]: any;
}