#修改 1. 新增DO单，DO单明细

skyouc

2025-04-21 b9d414bc2d61b4824ce6a019b1c10f526f71ced1

 rsf-admin/src/config/MyDataProvider.js

@@ -1,148 +1,148 @@
import request from '../utils/request';
import * as Common from '../utils/common';
import request from "../utils/request";
import * as Common from "../utils/common";

const MyDataProvider = {
    // *** https://marmelab.com/react-admin/DataProviderWriting.html ***
  // *** https://marmelab.com/react-admin/DataProviderWriting.html ***

    // get a list of records based on sort, filter, and pagination
    getList: async (resource, params) => {
        console.log("getList", resource, params);
        const _params = Common.integrateParams(params)
        const res = await request.post(resource + '/page', _params);
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: data.records,
                total: data.total
            });
        }
        return Promise.reject(new Error(msg));
    },

    // get a single record by id
    getOne: async (resource, params) => {
        console.log("getOne", resource, params);
        const res = await request.get(resource + '/' + params.id);
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: {
                    id: data.id,
                    ...data,
                },
            });
        }
        return Promise.reject(new Error(msg));
    },

    // get a list of records based on an array of ids
    getMany: async (resource, params) => {
        console.log("getMany", resource, params);
        const res = await request.post(resource + '/many/' + params.ids);
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: data.map(item => ({
                    id: item.id,
                    ...item,
                })),
            });
        }
        return Promise.reject(new Error(msg));
    },

    // get the records referenced to another record, e.g. comments for a post
    getManyReference: async (resource, params) => {
        console.log("getManyReference", resource, params);

        return Promise.resolve();
    },

    // create a record
    create: async (resource, params) => {
        console.log("create", resource, params);
        const res = await request.post(resource + '/save', params?.data);
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: {
                    id: data.id
                },
            });
        }
        return Promise.reject(new Error(msg));
    },

    // update a record based on a patch
    update: async (resource, params) => {
        console.log("update", resource, params);
        const res = await request.post(resource + '/update', { id: params.id, ...params.data });
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: data,
            });
        }
        return Promise.reject(new Error(msg));
    },

    // update a list of records based on an array of ids and a common patch
    updateMany: async (resource, params) => {
        console.log("updateMany", resource, params);
        const res = await request.post(
            resource + '/update/many'
            , params.ids.map(id => ({ id, ...params.data }))
        );
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: data,
            });
        }
        return Promise.reject(new Error(msg));
    },

    // delete a record by id
    delete: async (resource, params) => {
        console.log("delete", resource, params);
        const res = await request.post(resource + '/remove/' + [params.id]);
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: {
                    id: params.id
                },
            });
        }
        return Promise.reject(new Error(msg));
    },

    // delete a list of records based on an array of ids
    deleteMany: async (resource, params) => {
        console.log("deleteMany", resource, params);
        const res = await request.post(resource + '/remove/' + params?.ids);
        const { code, msg, data } = res.data;
        if (code === 200) {
            return Promise.resolve({
                data: data,
            });
        }
        return Promise.reject(new Error(msg));
    },

    // export excel from all data
    export: async (resource, params) => {
        console.log("export", resource, params);
        const _params = Common.integrateParams(params);
        try {
            const res = await request.post(`${resource}/export`, _params, {
                responseType: 'blob',
            });
            return res;
        } catch (error) {
            return Promise.reject(new Error(error));
        }
  // get a list of records based on sort, filter, and pagination
  getList: async (resource, params) => {
    // console.log("getList", resource, params);
    const _params = Common.integrateParams(params);
    const res = await request.post(resource + "/page", _params);
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: data.records,
        total: data.total,
      });
    }
}
    return Promise.reject(new Error(msg));
  },

export default MyDataProvider;
  // get a single record by id
  getOne: async (resource, params) => {
    // console.log("getOne", resource, params);
    const res = await request.get(resource + "/" + params.id);
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: {
          id: data.id,
          ...data,
        },
      });
    }
    return Promise.reject(new Error(msg));
  },

  // get a list of records based on an array of ids
  getMany: async (resource, params) => {
    // console.log("getMany", resource, params);
    const res = await request.post(resource + "/many/" + params.ids);
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: data.map((item) => ({
          id: item.id,
          ...item,
        })),
      });
    }
    return Promise.reject(new Error(msg));
  },

  // get the records referenced to another record, e.g. comments for a post
  getManyReference: async (resource, params) => {
    console.log("getManyReference", resource, params);

    return Promise.resolve();
  },

  // create a record
  create: async (resource, params) => {
    const res = await request.post(resource + "/save", params?.data);
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: {
          id: data.id,
        },
      });
    }
    return Promise.reject(new Error(msg));
  },

  // update a record based on a patch
  update: async (resource, params) => {
    const res = await request.post(resource + "/update", {
      id: params.id,
      ...params.data,
    });
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: data,
      });
    }
    return Promise.reject(new Error(msg));
  },

  // update a list of records based on an array of ids and a common patch
  updateMany: async (resource, params) => {
    console.log("updateMany", resource, params);
    const res = await request.post(
      resource + "/update/many",
      params.ids.map((id) => ({ id, ...params.data })),
    );
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: data,
      });
    }
    return Promise.reject(new Error(msg));
  },

  // delete a record by id
  delete: async (resource, params) => {
    console.log("delete", resource, params);
    const res = await request.post(resource + "/remove/" + [params.id]);
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: {
          id: params.id,
        },
      });
    }
    return Promise.reject(new Error(msg));
  },

  // delete a list of records based on an array of ids
  deleteMany: async (resource, params) => {
    console.log("deleteMany", resource, params);
    const res = await request.post(resource + "/remove/" + params?.ids);
    const { code, msg, data } = res.data;
    if (code === 200) {
      return Promise.resolve({
        data: data,
      });
    }
    return Promise.reject(new Error(msg));
  },

  // export excel from all data
  export: async (resource, params) => {
    const _params = Common.integrateParams(params);
    try {
      const res = await request.post(`${resource}/export`, _params, {
        responseType: "blob",
      });
      return res;
    } catch (error) {
      return Promise.reject(new Error(error));
    }
  },
};

export default MyDataProvider;