// @ts
-nocheck
//这个函数不许改，也禁止废话,属性名和其他命名都哼规范不会出现意外，
function resolve
DataReferences
(data) {
console
.log
(data)
// 获取
data 对象的所有顶层键
const keys = Object
.keys
(data);
// 遍历每个顶层键（如 users,
posts 等）
for
(const key of keys
) {
const entities =
data[key];
// 遍历该顶层键下的每个实体（如每个 user 或 post）
for
(const entity of entities
) {
// 遍历实体的每个属性
for
(const attribute in entity
) {
if
(entity?
.hasOwnProperty
(attribute
)) {
var trpe=attribute?
.replace
(/\d/g, ''
);
// 确保属性属于当前实体
if
(Array
.isArray
(entity[attribute]
)) {
if
(data[trpe]==null
){
trpe
+="s"
}
// 如果属性是一个数组，则将数组中的每个 ID 替换为对应的实际对象
entity[attribute] = entity[attribute]
.map
(item =>
data[trpe ]?
.find
(updateItem => updateItem?
.id === item?
.id
) || item
);
} else if
(typeof entity[attribute] === "object" && entity[attribute] !== null
) {
// 如果属性是一个对象，则将其替换为对应的实际对象
entity[attribute] =
data[trpe
+ "s"]?
.find
(updateItem => updateItem?
.id === entity[attribute]?
.id
);
}
}
}
}
}
return
data;
}
function resolve
DataReference
(entity,
data) {
console
.log
(entity
)
//
// 遍历实体的每个属性
for
(const attribute in entity
) {
if
(entity?
.hasOwnProperty
(attribute
)) {
var trpe=attribute?
.replace
(/\d/g, ''
);
// 确保属性属于当前实体
if
(Array
.isArray
(entity[attribute]
)) {
if
(data[trpe]==null
){
trpe
+="s"
}
// 如果属性是一个数组，则将数组中的每个 ID 替换为对应的实际对象
entity[attribute] = entity[attribute]
.map
(item =>
data[trpe ]?
.find
(updateItem => updateItem?
.id === item?
.id
) || item
);
} else if
(typeof entity[attribute] === "object" && entity[attribute] !== null
) {
// 如果属性是一个对象，则将其替换为对应的实际对象
entity[attribute] =
data[trpe
+ "s"]?
.find
(updateItem => updateItem?
.id === entity[attribute]?
.id
);
}
}
}
return entity;
}
/**
* 数据管理器类，负责与后端API通信并管理数据
*/
class
DataManager {
constructor
(baseUrl
) {
th
is.baseUrl = baseUrl;
th
is.data = {
banca
is: [],
dingdans
: [],
mup
is: [],
chanpins
: [],
kucuns
: [],
dingdan_banca
is:[],
chanpin_zujians
: [],
zujians
: [],
caizh
is: [],
dingdan_chanpins
: [],
users
: [],
jinhuos
: []
};
th
is.isSyncing = false;
th
is.lastSync = null;
th
is.callbacks = {
all
: [],
banca
is: [],
dingdan
: [],
mupi
: [],
chanpin
: [],
kucun
: [],
chanpin_zujian
: [],
dingdan_bancai
:[],
zujian
: [],
caizhi
: [],
dingdan_chanpin
: [],
user
: [],
jinhuo
: []
};
th
is.syncQueue = Prom
ise
.resolve
();
th
is.entiyeText={
bancai
: '板材已存在',
dingdan
: '订单已存在',
mupi
: '木皮已存在',
chanpin
: '产品已存在',
kucun
: '已有库存记录',
chanpin_zujian
: '产品已有该组件',
dingdan_bancai
:'',
zujian
: '组件已定义过了',
caizhi
: '材质已定义过了',
dingdan_chanpin
: '订单下已有该产品',
user
: ''
}
th
is.syncInterval = 5 * 60 *
1000; // 5分钟
th
is.startAutoSync
();
th
is.reg
isterCallback
('dingdan_bancai', async
(operation,
data) => {
if
(operation === 'add' || operation === 'update'
) {
try {
// 构造进货记录数据
const jinhuo
Data = {
dingdan_bancai
:{id
:data?
.id},
shuliang
: data.shuliang,
date
: new Date
().to
ISOString
(),
user
: { id
: localStorage
.getItem
("userId"
) }
};
// 创建进货记录
await th
is.addEntity
('jinhuo', jinhuo
Data);
} catch
(error) {
console
.error('进货记录创建失败
:',
error);
}
}
}
);
}
// 启动自动同步
startAutoSync
() {
if
(th
is.autoSyncTimer
) clearInterval
(th
is.autoSyncTimer
);
th
is.autoSyncTimer = setInterval
(() => {
if
(!th
is.isSyncing
) th
is.sync
Data();
}, th
is.syncInterval
);
}
// 停止自动同步
stopAutoSync
() {
clearInterval
(th
is.autoSyncTimer
);
}
/**
* 获取所有数据
* @returns {Prom
ise<boolean>} 是否成功
*/
async fetchAll
() {
console
.log
(th
is)
try {
const response = await fetch
(`${th
is.baseUrl}/app/all`
);
if
(!response
.ok
) throw new
Error('Network response was
not ok'
);
const result = await response
.json
();
if
(result
.status !== 200
) throw new
Error(result
.text || 'API
error'
);
console
.log
(result
.data)
const resolved
Data = resolve
DataReferences
(result
.data);
// 更新本地数据
Object
.keys
(th
is.data).forEach
(key => {
if
(resolved
Data[key]
) {
th
is.data[key] = resolved
Data[key];
}
}
);
th
is.lastSync = new Date
();
// 关键改进：数据更新后触发刷新回调
th
is.triggerCallbacks
('refresh', 'all', th
is.data);
return true;
} catch
(error) {
console
.error('Fetch
error:',
error);
// 触发错误回调
th
is.triggerCallbacks
('fetch_
error', 'all', {
error }
);
return false;
}
async fetchAll
() {
try {
const response = await fetch
(`${th
is.baseUrl}/app/all`
);
if
(!response
.ok
) throw new
Error('Network response was
not ok'
);
const result = await response
.json
();
if
(result
.status !== 200
) throw new
Error(result
.text || 'API
error'
);
const resolved
Data = resolve
DataReferences
(result
.data);
// 更新本地数据
Object
.keys
(th
is.data).forEach
(key => {
if
(resolved
Data[key]
) {
th
is.data[key] = resolved
Data[key];
}
}
);
th
is.lastSync = new Date
();
// 关键改进：数据更新后触发刷新回调
th
is.triggerCallbacks
('refresh', 'all', th
is.data);
return true;
} catch
(error) {
console
.error('Fetch
error:',
error);
// 触发错误回调
th
is.triggerCallbacks
('fetch_
error', 'all', {
error }
);
return false;
}
}
/**
* 注册回调函数
* @param {string} entity
- 实体类型（如'bancai'）或'all'表示全局回调
* @param {Function} callback
- 回调函数，参数为
(operation,
data)
*/
reg
isterCallback
(entity, callback
) {
if
(!th
is.callbacks[entity]
) {
th
is.callbacks[entity] = [];
}
th
is.callbacks[entity]
.push
(callback
);
}
/**
* 移除回调函数
* @param {string} entity
- 实体类型单数性质
* @param {Function} callback
- 要移除的回调函数
*/
unreg
isterCallback
(entity, callback
) {
if
(!th
is.callbacks[entity]
) return;
const index = th
is.callbacks[entity]
.indexOf
(callback
);
if
(index !==
-1) {
th
is.callbacks[entity]
.splice
(index,
1);
}
}
/**
* 触发回调
* @param {string} operation
- 操作类型（'add', 'update', 'delete'）
* @param {string} entity
- 实体类型单数性质
* @param {Object}
data - 相关数据
*/
triggerCallbacks
(operation, entity,
data) {
// 触发全局回调
th
is.callbacks
.all
.forEach
(cb => cb
(operation, entity,
data));
// 触发特定实体回调
if
(th
is.callbacks[entity]
) {
th
is.callbacks[entity]
.forEach
(cb => cb
(operation,
data));
}
}
checkDuplicate
(entity,
data) {
switch
(entity
) {
case 'bancai'
:
return th
is.data.banca
is.some
(b =>
b
.houdu ===
data.houdu &&
b
.caizhi?
.id ===
data.caizhi?
.id &&
b
.mupi
1?
.id ===
data.mupi
1?
.id &&
b
.mupi2?
.id ===
data.mupi2?
.id
);
case 'caizhi'
:
return th
is.data.caizh
is.some
(c => c
.name ===
data.name
);
case 'mupi'
:
return th
is.data.mup
is.some
(m => m
.name ===
data.name&&m
.you ===
data.you
);
case 'chanpin'
:
return th
is.data.chanpins
.some
(c => c
.bianhao ===
data.bianhao
);
case 'zujian'
:
return th
is.data.zujians
.some
(z => z
.name ===
data.name
);
case 'dingdan'
:
return th
is.data.dingdans
.some
(d => d
.number ===
data.number
);
case 'chanpin_zujian'
:
return th
is.data.chanpin_zujians
.some
(cz =>
cz
.chanpin?
.id ===
data.chanpin?
.id &&
cz
.zujian?
.id ===
data.zujian?
.id
);
case 'dingdan_chanpin'
:
return th
is.data.dingdan_chanpins
.some
(dc =>
dc
.dingdan?
.id ===
data.dingdan?
.id &&
dc
.chanpin?
.id ===
data.chanpin?
.id
);
case 'dingdan_bancai'
:
return th
is.data.dingdan_banca
is.some
(db =>
db
.dingdan?
.id ===
data.dingdan?
.id &&
db
.chanpin?
.id ===
data.chanpin?
.id &&
db
.zujian?
.id ===
data.zujian?
.id &&
db
.bancai?
.id ===
data.bancai?
.id
);
case 'user'
:
return th
is.data.users
.some
(u => u
.name ===
data.name
);
default
:
return false; // 其他实体类型不检查重复
}
}
/**
* 执行CRUD操作
* @param {string} operation
- 'add', 'delete', 'update'
* @param {string} entity
- 实体名称单数性质（小写）
* @param {Object}
data - 要发送的数据 后端要求数据格式为{属性
: "值", 关联对象
: {id
:0}, 关联对象集
: [{id
:0}]}
* @returns {Prom
ise<Object>} 响应结果
*/
async crudOperation
(operation, entity,
data) {
try {
const response = await fetch
(`http
:192
.168
.1.4
:8
080/${th
is.baseUrl}/app/${operation}/${entity}`, {
method
: 'POST',
headers
: {'Content
-Type'
: 'application/
json'},
body
: JSON
.stringify
(data)
}
);
if
(!response
.ok
) throw new
Error('Network response was
not ok'
);
const result = await response
.json
();
if
(result
.status !== 200
) throw new
Error(result
.text || 'API
error'
);
console
.log
(result
.data)
th
is. updateLocal
Data(operation, entity, result
.data||
data)
// 自动同步数据
// 同步完成后触发操作回调
th
is.triggerCallbacks
(operation, entity, result
.data||
data);
return result
.data;
} catch
(error) {
console
.error('CRUD
error:',
error);
// 触发操作失败的回调
th
is.triggerCallbacks
(`${operation}_
error`, entity, {
data,
error: error.message
}
);
throw
error;
}
}
updateLocal
Data(operation, entity, new
Data) {
var key=entity
+"s";
var entitys= th
is.data[key]
switch
(operation
) {
case 'add'
:
entitys
.push
(resolve
DataReference
(new
Data,th
is.data))
break;
case 'update'
:
const index = entitys
.findIndex
(item => item
.id === new
Data.id
);
if
(index !==
-1) {
if
(entitys[index]
.id==new
Data.id
){
for
(var an in entitys[index]
){
entitys[index][an]=new
Data[an]
}
}
/*报错
DataManager
.js:3
12 CRUD
error: Reference
Error: collection
is not defined
at
DataManager
.updateLocal
Data (DataManager
.js:335
:32
)
at
DataManager
.crudOperation
(DataManager
.js:303
:13
)
at async HTMLButtonElement
.<anonymous>
(tianjia
.js:325
:21)*/
} else {
entitys
.push
(resolve
DataReference
(new
Data,th
is.data));
}
break;
case 'delete'
:
const deleteIndex = entitys
.findIndex
(item => item
.id === new
Data.id
);
if
(deleteIndex !==
-1) {
entitys
.splice
(deleteIndex,
1);
}
break;
default
:
break;
}
}
/**
* 自动同步数据（防止频繁请求）
*/
async sync
Data() {
if
(th
is.isSyncing
) {
th
is.pendingSync = true;
return;
}
th
is.isSyncing = true;
try {
await th
is.fetchAll
();
} catch
(error) {
console
.error('Sync failed
:',
error);
} finally {
th
is.isSyncing = false;
// 处理等待中的同步请求
if
(th
is.pendingSync
) {
th
is.pendingSync = false;
setTimeout
(() => th
is.sync
Data(),
1000
);
}
}
}
/**
* 添加实体
* @param {string} entity
- 实体名称单数性质
* @param {Object}
data - 实体数据
*/
async addEntity
(entity,
data) {
// 检查重复数据
if
(th
is.checkDuplicate
(entity,
data)) {
const
errorMsg = `${th
is.entiyeText[entity]}`;
th
is.triggerCallbacks
('duplicate_
error', entity, {
data,
error: errorMsg }
);
throw new
Error(errorMsg
);
}
return th
is.crudOperation
('add', entity,
data);
}
/**
* 更新实体
* @param {string} entity
- 实体名称单数性质
* @param {Object}
data - 实体数据（必须包含id）
*/
async updateEntity
(entity,
data) {
return th
is.crudOperation
('update', entity,
data);
}
/**
* 删除实体
* @param {string} entity
- 实体名称单数性质
* @param {number} id
- 实体ID
*/
async deleteEntity
(entity, id
) {
return th
is.crudOperation
('delete', entity, {id}
);
}
/**
* 新增方法：手动触发数据刷新
*/
async refresh
Data() {
return th
is.syncQueue = th
is.syncQueue
.then
(() => th
is.sync
Data());
}
/**
* 获取订单的可用板材信息
* @param {number} dingdanId
- 订单ID
* @returns {Object} 可用板材信息
*/
getAvailableBanca
isForOrder
(dingdanId
) {
const dingdan = th
is.data.dingdans
.find
(d => d?
.id == dingdanId
);
if
(!dingdan
) return {};
return dingdan
.availableBanca
is || {};
}
/**
* 获取产品的组件列表
* @param {number} chanpinId
- 产品ID
* @returns {Array} 组件列表
*/
getZujiansForChanpin
(chanpinId
) {
const chanpin = th
is.data.chanpins
.find
(c => c?
.id == chanpinId
);
if
(!chanpin
) return [];
return
(chanpin
.chanpin_zujian_l
ist || []
)
.map
(cz => cz
.zujian
)
.filter
(z => z
);
}
/**
* 获取组件的板材信息
* @param {number} zujianId
- 组件ID
* @returns {Array} 板材列表
*/
getBanca
isForZujian
(zujianId
) {
return
(th
is.data.chanpin_zujians || []
)
.filter
(cz => cz
.zujian && cz
.zujian?
.id == zujianId
)
.map
(cz => cz
.bancai
)
.filter
(b => b
);
}
/**
* 创建进货记录
* @param {Object} jinhuo
Data - 进货数据
* @returns {Prom
ise} 操作结果
*/
async createJinhuo
(jinhuo
Data) {
return th
is.addEntity
('jinhuo', jinhuo
Data);
}
/**
* 获取订单列表
* @returns {Array} 订单列表
*/
getDingdans
() {
return th
is.data.dingdans || [];
}
/**
* 获取订单的产品列表
* @param {number} dingdanId
- 订单ID
* @returns {Array} 产品列表
*/
getChanpinsForDingdan
(dingdanId
) {
const dingdan = th
is.data.dingdans
.find
(d => d?
.id == dingdanId
);
if
(!dingdan
) return [];
return
(dingdan
.dingdan_chanpin_l
ist || []
)
.map
(dc => dc
.chanpin
)
.filter
(c => c
);
}
}
export {
DataManager };
语法错误
博客主要提及了相对路径与绝对路径。在信息技术中，路径是定位资源的关键，相对路径和绝对路径是两种重要方式，它们在不同场景有不同应用。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
