refactor: taro

zhengyiming

2025-02-20 703c46d17731d1b437509f326c050d1d36838f74

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
import {
  EnterpriseMaterialFileBusinessTypeEnumText,
  EnterpriseMaterialFileBusinessTypeEnum,
  DutiableFileBusinessTypeEnumText,
  EnterpriseMaterialTypeEnum,
} from '@/constants';
import { UploadUserFile } from '@bole-core/components';
import { getFileExtension } from '@bole-core/core';
import { convertApi2FormUrl } from '../common/file';
 
export type EnterpriseMaterialFileTableItem = {
  fileBusinessType: EnterpriseMaterialFileBusinessTypeEnum;
  fileList: (API.AddEnterpriseMaterialFileInput & UploadUserFile)[];
  lastModificationTime?: string;
  lastModifierName?: string;
};
 
export class EnterpriseMaterialUtils {
  static createEnterpriseMaterialFileTableItem(
    fileBusinessType: EnterpriseMaterialFileBusinessTypeEnum
  ) {
    return {
      fileBusinessType: fileBusinessType,
      fileList: [],
      lastModificationTime: '',
      lastModifierName: '',
    } as EnterpriseMaterialFileTableItem;
  }
 
  static convertFileBusinessTypeToList(materialType = EnterpriseMaterialTypeEnum.FourStreams) {
    return Object.keys(
      materialType === EnterpriseMaterialTypeEnum.FourStreams
        ? EnterpriseMaterialFileBusinessTypeEnumText
        : DutiableFileBusinessTypeEnumText
    ).map((x) => this.createEnterpriseMaterialFileTableItem(Number(x)));
  }
 
  static convertFileTableListToApi(fileTableList: EnterpriseMaterialFileTableItem[]) {
    const addEnterpriseMaterialFileList: API.AddEnterpriseMaterialFileInput[] = [];
    fileTableList.forEach((fileTableListItem) => {
      fileTableListItem.fileList
        .filter((fileItem) => fileItem.status === 'success')
        .forEach((fileItem) => {
          addEnterpriseMaterialFileList.push({
            fileBusinessType: fileTableListItem.fileBusinessType,
            fileUrl: fileItem.path,
            fileSize: fileItem.size,
            fileExtension: getFileExtension(fileItem.url),
          });
        });
    });
 
    return addEnterpriseMaterialFileList;
  }
 
  static isFileTableListAllUploaded(fileTableList: EnterpriseMaterialFileTableItem[]) {
    return fileTableList.every((fileTableListItem) => {
      return fileTableListItem.fileList.every((fileItem) => {
        return fileItem.status === 'success';
      });
    });
  }
 
  static convertApiFileToTableList(
    materialItemOutputList: API.EnterpriseMaterialItemOutput[],
    materialType = EnterpriseMaterialTypeEnum.FourStreams
  ) {
    const fileTableList = this.convertFileBusinessTypeToList(materialType);
 
    materialItemOutputList.forEach((materialItemOutput) => {
      const item = fileTableList.find(
        (x) => x.fileBusinessType === materialItemOutput.fileBusinessType
      );
      if (item) {
        item.fileList = materialItemOutput.materialFileItemList.map((materialFileItem) => ({
          ...materialFileItem,
          ...convertApi2FormUrl(materialFileItem.fileUrl),
          size: materialFileItem.fileSize,
        }));
        item.lastModificationTime = materialItemOutput.lastModificationTime ?? '';
        item.lastModifierName = materialItemOutput.lastModifierName ?? '';
      }
    });
 
    return fileTableList;
  }
}