// 解析数据引用关系的辅助函数
/**
* 解析数据中的引用关系
* 该函数用于处理嵌套的数据结构，将数据中的引用关系解析为实际的对象引用。
* 它会遍历数据中的所有实体，查找属性名中包含的数字（如"item1"），
* 并尝试将这些属性值替换为对应类型数据中的实际对象引用。
* @param {Object}
data - 包含嵌套引用的原始数据对象
* @returns {Object} 处理后的数据对象，其中引用已被解析为实际对象
*/
function resolve
DataReferences(
data) {
const keys = Object.keys(
data);
for (const key of keys) {
const entities =
data[key];
for (const entity of entities) {
for (const attribute in entity) {
if (entity.hasOwnProperty(attribute)) {
// 修复：统一使用复数形式查找引用类型
let refType = attribute.replace(/\d/g, '');
// 尝试直接查找复数形式
if (!
data[refType] &&
data[`${refType}s`]) {
refType = `${refType}s`;
}
if (Array.isArray(entity[attribute])) {
entity[attribute] = entity[attribute].map(item =>
data[refType]?.find(updateItem => updateItem.id === item.id) || item
);
} else if (typeof entity[attribute] === "object" && entity[attribute] !== null) {
entity[attribute] =
data[refType]?.find(updateItem => updateItem.id === entity[attribute].id) ||
entity[attribute];
}
}
}
}
}
return
data;
}
// 解析单个实体的数据引用
/**
* 解析数据引用关系
* 该函数用于处理实体对象与数据源之间的引用关系，自动匹配并更新实体中的引用字段。
* @param {Object} entity - 需要处理的实体对象
* @param {Object}
data - 包含引用数据的数据源对象
* @returns {Object} 处理后的实体对象
* 功能说明：
* 遍历实体对象的每个属性
* 如果属性值是数组，则尝试在数据源中查找匹配项更新数组元素
* 如果属性值是对象，则尝试在数据源中查找匹配项更新该对象
* 自动处理单复数形式的数据源键名
*/
function resolve
DataReference(entity,
data) {
for (const attribute in entity) {
if (entity.hasOwnProperty(attribute)) {
// 修复：统一使用复数形式查找引用类型
let refType = attribute.replace(/\d/g, '');
// 尝试直接查找复数形式
if (!
data[refType] &&
data[`${refType}s`]) {
refType = `${refType}s`;
}
if (Array.isArray(entity[attribute])) {
entity[attribute] = entity[attribute].map(item =>
data[refType]?.find(updateItem => updateItem.id === item.id) || item
);
} else if (typeof entity[attribute] === "object" && entity[attribute] !== null) {
entity[attribute] =
data[refType]?.find(updateItem => updateItem.id === entity[attribute].id) ||
entity[attribute];
}
}
}
return entity;
}
/**
* 懒加载处理器
* 负责管理实体类之间的关联依赖，实现按需加载
*/
class LazyLoader {
constructor(
dataManager) {
this.
dataManager =
dataManager;
this.cache = new Map();
this.entityTypeMap = {
bancai
: 'bancais',
dingdan
: 'dingdans',
mupi
: 'mupis',
chanpin
: 'chanpins',
kucun
: 'kucuns',
dingdan_bancai
: 'dingdan_bancais',
chanpin_zujian
: 'chanpin_zujians',
zujian
: 'zujians',
caizhi
: 'caizhis',
dingdan_chanpin
: 'dingdan_chanpins',
user
: 'users',
jinhuo
: 'jinhuos'
};
}
/**
* 创建实体代理
* @param {Object} entity 实体对象
* @param {string} entityType 实体类型
* @returns {Proxy} 返回代理后的实体
*/
createProxy(entity, entityType) {
const handler = {
get
: (target, prop) => {
// 如果是普通属性，直接返回
if (typeof target[prop] !== 'object' || target[prop] === null) {
return target[prop];
}
// 检查是否是引用属性
const refType = this.getReferenceType(prop);
if (refType) {
// 如果是数组引用
if (Array.isArray(target[prop])) {
return this.loadReferences(target[prop], refType);
}
// 如果是对象引用
else {
return this.loadReference(target[prop], refType);
}
}
return target[prop];
}
};
if(!entity.__isProxy)return new Proxy(entity, handler);
return entity;
}
/**
* 获取引用类型
* @param {string} prop 属性名
* @returns {string|null} 引用类型（复数形式）
*/
getReferenceType(prop) {
// 去除数字后缀（如 "mupi1" -> "mupi"）
const baseProp = prop.replace(/\d/g, '');
// 尝试直接匹配实体类型
if (this.entityTypeMap[baseProp]) {
return this.entityTypeMap[baseProp];
}
// 尝试添加 's' 后缀匹配
const pluralProp = `${baseProp}s`;
if (this.
dataManager._
rawData[pluralProp]) {
return pluralProp;
}
return null;
}
/**
* 加载单个关联引用
* @param {Object} ref 引用对象（包含id）
* @param {string} refType 引用类型（复数形式）
* @returns {Promise<Object>} 解析后的实体对象
*/
loadReference(ref, refType) {
if (!ref || !ref.id) { return null;}
const cacheKey = `${refType}_${ref.id}`;
// 检查缓存
if (this.cache.has(cacheKey)) {
return this.cache.get(cacheKey);
}
// 尝试从本地数据查找
const entities = this.
dataManager._
rawData[refType] || [];
let entity = entities.find(e => e.id === ref.id);
// 如果本地找不到，尝试同步数据
if (!entity) {
//this.
dataManager.sync
Data();
entity = (this.
dataManager._
rawData[refType] || []).find(e => e.id === ref.id);
}
if (entity) {
// 递归解析嵌套引用
const resolvedEntity = resolve
DataReference({...entity}, this.
dataManager._
rawData);
// 创建代理并缓存
const proxy = this.createProxy(resolvedEntity, refType);
this.cache.set(cacheKey, proxy);
return proxy;
}
return ref; // 返回原始引用
}
/**
* 加载多个关联引用
* @param {Array} refs 引用对象数组
* @param {string} refType 引用类型（复数形式）
* @returns {Promise<Array>} 解析后的实体对象数组
*/
loadReferences(refs, refType) {
if (!Array.isArray(refs)) return [];
return Promise.all(
refs.map(ref => this.loadReference(ref, refType))
);
}
/**
* 清除缓存
*/
clearCache() {
this.cache.clear();
}
}
class MiniProgram
DataManager {
constructor(baseUrl) {
this.baseUrl = baseUrl;
this.debug = true; // 调试模式开关
this.requestCount = 0; // 请求计数器
// 数据结构定义
this._
rawData = {
bancais
: [], dingdans
: [], mupis
: [], chanpins
: [], kucuns
: [],
dingdan_bancais
: [], chanpin_zujians
: [], zujians
: [], caizhis
: [],
dingdan_chanpins
: [], users
: [], jinhuos
: [],
_lastModified
: null, _lastSync
: null
};
// 初始化网络状态
this.networkAvailable = false;
this.checkNetwork().then(type => {
this.networkAvailable = type !== 'none';
});
this.lazyLoader = new LazyLoader(this);
this.load
DataFromStorage();
this.isSyncing = false;
this.lastSync = null;
this.callbacks = {
all
: [], bancais
: [], dingdan
: [], mupi
: [], chanpin
: [], kucun
: [],
chanpin_zujian
: [], dingdan_bancai
: [], zujian
: [], caizhi
: [],
dingdan_chanpin
: [], user
: [], jinhuo
: []
};
this.syncQueue = Promise.resolve();
this.entiyeText = {
bancai
: '板材已存在', dingdan
: '订单已存在', mupi
: '木皮已存在',
chanpin
: '产品已存在', kucun
: '已有库存记录',
chanpin_zujian
: '产品已有该组件', dingdan_bancai
: '',
zujian
: '组件已定义过了', caizhi
: '材质已定义过了',
dingdan_chanpin
: '订单下已有该产品', user
: ''
};
this.syncInterval = 5 * 60 * 1000; // 5分钟
this.storageKey = 'miniProgram
Data'; // 本地存储的键名
}
get
data() {
// 创建数据代理
const handler = {
get
: (target, prop) => {
// 处理特殊属性
if (prop.startsWith('_')) {
return target[prop];
}
// 处理数组类型的实体集合
if (Array.isArray(target[prop])) {
return target[prop].map(item =>
this.lazyLoader.createProxy(item, prop.replace(/s$/, ''))
);
}
if (typeof target[prop] == 'object' && target[prop] === null) {
return this.lazyLoader.createProxy(item, prop)
}
// 默认返回原始值
return target[prop];
},
// 保持其他操作不变
set
: (target, prop, value) => {
target[prop] = value;
return true;
}
};
return new Proxy(this._
rawData, handler);
}
// 添加显式初始化方法
async initialize() {
console.log('初始化数据管理器...');
// 先尝试从本地存储加载数据
this.load
DataFromStorage();
// 检查是否有本地数据
const hasLocal
Data = this._
rawData._lastSync !== null;
console.log('本地存储数据状态
:', hasLocal
Data ? '有数据'
: '无数据');
// 启动自动同步
this.startAutoSync();
// 执行首次数据同步
try {
await this.sync
Data();
console.log('数据同步完成');
// 打印数据统计
const stats = {
bancais
: this._
rawData.bancais.length,
kucuns
: this._
rawData.kucuns.length,
dingdans
: this._
rawData.dingdans.length,
chanpins
: this._
rawData.chanpins.length
};
console.log('数据统计
:', stats);
return true;
} catch (error) {
console.error('数据同步失败
:', error);
// 如果同步失败但有本地数据，仍然返回成功
if (hasLocal
Data) {
console.log('使用本地缓存数据');
return true;
}
throw error;
}
}
/**
* 启动自动同步定时器
* 每隔syncInterval毫秒检查并执行数据同步
* 如果已有同步任务进行中则跳过
*/
startAutoSync() {
if (this.autoSyncTimer) clearInterval(this.autoSyncTimer);
this.autoSyncTimer = setInterval(() => {
if (!this.isSyncing) this.sync
Data();
}, this.syncInterval);
}
/**
* 停止自动同步
*/
stopAutoSync() {
clearInterval(this.autoSyncTimer);
}
/**
* 检查网络状态
*/
checkNetwork() {
return new Promise((resolve) => {
wx.getNetworkType({
success
: (res) => {
resolve(res.networkType);
},
fail
: () => {
resolve('unknown');
}
});
});
}
/**
* 获取所有数据（全量或增量）
* @async
* @param {string} [since] - 增量获取的时间戳，不传则全量获取
* @returns {Promise} 是否获取成功
* @description
* 根据since参数决定全量或增量获取数据
* 增量获取时会合并新数据到现有数据
* 全量获取会直接替换现有数据
* 成功后会更新同步时间并保存到本地存储
* 失败时会触发错误回调，若无历史数据则抛出错误
*/
async fetchAll(since) {
try {
console.log(since ? `增量获取数据(自${since})...`
: '全量获取数据...');
let resolved
Data;
// 如果baseUrl为空，尝试加载本地测试数据
if (!this.baseUrl) {
console.log('使用本地测试数据');
try {
// 尝试从本地存储加载数据
this.load
DataFromStorage();
// 如果本地存储没有数据，尝试加载测试数据
if (!this._
rawData._lastSync) {
console.log('本地存储无数据，尝试加载测试数据');
// 创建测试数据
const test
Data = this.createTest
Data();
resolved
Data = test
Data;
console.log('已创建测试数据');
} else {
console.log('使用本地存储的数据');
return true; // 已经从本地存储加载了数据
}
} catch (e) {
console.error('加载本地测试数据失败
:', e);
throw new Error('无法加载测试数据');
}
} else {
// 正常从API获取数据
const params = since ? { since }
: {};
resolved
Data = await this.request('/app/all', 'GET', params);
}
// 更新network
Data
if (resolved
Data) {
Object.keys(this._
rawData).forEach(key => {
if (key.startsWith('_')) return;
if (resolved
Data[key]) {
if (since) {
// 增量更新
: 合并新数据到现有数据
resolved
Data[key].forEach(newItem => {
const
index = this._
rawData[key].find
Index(item => item.id === newItem.id);
if (
index >= 0) {
this._
rawData[key][
index] = newItem;
} else {
this._
rawData[key].push(newItem);
}
});
} else {
// 全量更新
: 直接替换
this._
rawData[key] = resolved
Data[key];
}
}
});
}
// 更新同步时间
this.lastSync = new Date();
this._
rawData._lastSync = this.lastSync.toISOString();
// 保存到本地存储
this.save
DataToStorage();
this.triggerCallbacks('refresh', 'all', this.
data);
return true;
} catch (error) {
console.error('Fetch error
:', error);
this.triggerCallbacks('fetch_error', 'all', { error });
// 失败时尝试使用本地数据
if (!this.lastSync) {
throw new Error('初始化数据获取失败');
}
return false;
}
}
// 创建测试数据
createTest
Data() {
console.log('创建测试数据');
// 创建材质数据
const caizhis = [
{ id
: 1, name
: '实木' },
{ id
: 2, name
: '密度板' },
{ id
: 3, name
: '多层板' }
];
// 创建木皮数据
const mupis = [
{ id
: 1, name
: '橡木', you
: false },
{ id
: 2, name
: '胡桃木', you
: true },
{ id
: 3, name
: '枫木', you
: false }
];
// 创建板材数据
const bancais = [
{
id
: 1,
houdu
: 18,
caizhi
: { id
: 1 },
mupi1
: { id
: 1 },
mupi2
: null
},
{
id
: 2,
houdu
: 25,
caizhi
: { id
: 2 },
mupi1
: { id
: 2 },
mupi2
: { id
: 3 }
},
{
id
: 3,
houdu
: 12,
caizhi
: { id
: 3 },
mupi1
: { id
: 3 },
mupi2
: null
}
];
// 创建库存数据
const kucuns = [
{ id
: 1, bancai
: { id
: 1 }, shuliang
: 100 },
{ id
: 2, bancai
: { id
: 2 }, shuliang
: 50 },
{ id
: 3, bancai
: { id
: 3 }, shuliang
: 75 }
];
// 创建组件数据
const zujians = [
{ id
: 1, name
: '桌面' },
{ id
: 2, name
: '桌腿' },
{ id
: 3, name
: '抽屉' }
];
// 创建产品数据
const chanpins = [
{ id
: 1, name
: '办公桌', bianhao
: 'CP001' },
{ id
: 2, name
: '餐桌', bianhao
: 'CP002' },
{ id
: 3, name
: '书桌', bianhao
: 'CP003' }
];
// 创建产品组件关联
const chanpin_zujians = [
{ id
: 1, chanpin
: { id
: 1 }, zujian
: { id
: 1 }, bancai
: { id
: 1 } },
{ id
: 2, chanpin
: { id
: 1 }, zujian
: { id
: 2 }, bancai
: { id
: 2 } },
{ id
: 3, chanpin
: { id
: 2 }, zujian
: { id
: 1 }, bancai
: { id
: 3 } }
];
// 创建订单数据
const dingdans = [
{
id
: 1,
number
: 'DD001',
xiadan
: '2023-01-01T00
:00
:00.000Z',
jiaohuo
: '2023-01-15T00
:00
:00.000Z'
},
{
id
: 2,
number
: 'DD002',
xiadan
: '2023-02-01T00
:00
:00.000Z',
jiaohuo
: '2023-02-15T00
:00
:00.000Z'
}
];
// 创建订单产品关联
const dingdan_chanpins = [
{ id
: 1, dingdan
: { id
: 1 }, chanpin
: { id
: 1 }, shuliang
: 2 },
{ id
: 2, dingdan
: { id
: 1 }, chanpin
: { id
: 2 }, shuliang
: 1 },
{ id
: 3, dingdan
: { id
: 2 }, chanpin
: { id
: 3 }, shuliang
: 3 }
];
// 创建订单板材关联
const dingdan_bancais = [
{
id
: 1,
dingdan
: { id
: 1 },
chanpin
: { id
: 1 },
zujian
: { id
: 1 },
bancai
: { id
: 1 },
shuliang
: 2
},
{
id
: 2,
dingdan
: { id
: 1 },
chanpin
: { id
: 1 },
zujian
: { id
: 2 },
bancai
: { id
: 2 },
shuliang
: 8
},
{
id
: 3,
dingdan
: { id
: 1 },
chanpin
: { id
: 2 },
zujian
: { id
: 1 },
bancai
: { id
: 3 },
shuliang
: 1
}
];
// 创建用户数据
const users = [
{ id
: 1, name
: 'admin', password
: 'admin123' }
];
// 创建进货记录
const jinhuos = [
{
id
: 1,
kucun
: { id
: 1 },
shuliang
: 100,
date
: '2023-01-01T00
:00
:00.000Z',
text
: '初始库存',
theTypeOfOperation
: 1,
user
: { id
: 1 }
},
{
id
: 2,
kucun
: { id
: 2 },
shuliang
: 50,
date
: '2023-01-01T00
:00
:00.000Z',
text
: '初始库存',
theTypeOfOperation
: 1,
user
: { id
: 1 }
},
{
id
: 3,
kucun
: { id
: 3 },
shuliang
: 75,
date
: '2023-01-01T00
:00
:00.000Z',
text
: '初始库存',
theTypeOfOperation
: 1,
user
: { id
: 1 }
}
];
return {
bancais,
dingdans,
mupis,
chanpins,
kucuns,
dingdan_bancais,
chanpin_zujians,
zujians,
caizhis,
dingdan_chanpins,
users,
jinhuos
};
}
/**
* 微信小程序API请求封装
*/
request(url, method = 'GET',
data = null, retryCount = 3) {
return new Promise((resolve, reject) => {
const makeRequest = (attempt) => {
const fullUrl = `${this.baseUrl}${url}`;
if (this.debug) {
console.log(`[请求] ${method} ${fullUrl}`, {
attempt,
data,
timestamp
: new Date().toISOString()
});
}
wx.request({
url
: fullUrl,
method,
data,
header
: {
'Content-Type'
: 'application/json'
},
success
: (res) => {
if (this.debug) {
console.log(`[响应] ${fullUrl}`, {
status
: res.statusCode,
data: res.
data,
headers
: res.header
});
}
// 修复：更灵活的响应格式处理
if (!res.
data) {
const err = new Error('空响应数据');
if (attempt < retryCount) {
this.retryRequest(makeRequest, attempt, retryCount, err);
} else {
reject(err);
}
return;
}
// 修复：支持多种成功状态码和响应格式
const isSuccess = res.statusCode >= 200 && res.statusCode < 300;
const has
Data = res.
data && (res.
data.
data !==
undefined || typeof res.
data === 'object');
if (isSuccess && has
Data) {
resolve(res.
data.
data || res.
data);
} else {
const errMsg = res.
data.message || res.
data.text || 'API错误';
const err = new Error(errMsg);
if (attempt < retryCount) {
this.retryRequest(makeRequest, attempt, retryCount, err);
} else {
reject(err);
}
}
},
fail
: (err) => {
if (this.debug) {
console.error(`[失败] ${fullUrl}`, err);
}
const error = new Error(`网络请求失败
: ${err.errMsg || '未知错误'}`);
if (attempt < retryCount) {
this.retryRequest(makeRequest, attempt, retryCount, error);
} else {
reject(error);
}
}
});
};
makeRequest(1);
});
}
retryRequest(makeRequest, attempt, retryCount, error) {
const delay = 1000 * attempt;
console.warn(`请求失败 (${attempt}/${retryCount}), ${delay}ms后重试
:`, error.message);
setTimeout(() => makeRequest(attempt + 1), delay);
}
/**
* 注册回调函数
*/
registerCallback(entity, callback) {
if (!this.callbacks[entity]) {
this.callbacks[entity] = [];
}
this.callbacks[entity].push(callback);
}
/**
* 注销回调函数
*/
unregisterCallback(entity, callback) {
if (!this.callbacks[entity]) return;
const
index = this.callbacks[entity].
indexOf(callback);
if (
index !== -1) {
this.callbacks[entity].splice(
index, 1);
}
}
/**
* 触发回调函数
*/
triggerCallbacks(operation, entity,
data) {
this.callbacks.all.forEach(cb => cb(operation, entity,
data));
if (this.callbacks[entity]) {
this.callbacks[entity].forEach(cb => cb(operation,
data));
}
}
/**
* 检查重复实体
*/
checkDuplicate(entity,
data) {
// 修复：确保引用已解析
const resolved
Data = resolve
DataReference(
data, this.
data);
switch (entity) {
case 'bancai'
:
return this.
data.bancais.some(b =>
b.houdu === resolved
Data.houdu &&
b.caizhi?.id === resolved
Data.caizhi?.id &&
b.mupi1?.id === resolved
Data.mupi1?.id &&
b.mupi2?.id === resolved
Data.mupi2?.id
);
case 'caizhi'
:
return this.
data.caizhis.some(c => c.name === resolved
Data.name);
case 'mupi'
:
return this.
data.mupis.some(m =>
m.name === resolved
Data.name &&
m.you === resolved
Data.you
);
case 'chanpin'
:
return this.
data.chanpins.some(c => c.bianhao === resolved
Data.bianhao);
case 'zujian'
:
return this.
data.zujians.some(z => z.name === resolved
Data.name);
case 'dingdan'
:
return this.
data.dingdans.some(d => d.number === resolved
Data.number);
case 'chanpin_zujian'
:
return this.
data.chanpin_zujians.some(cz =>
cz.chanpin?.id === resolved
Data.chanpin?.id &&
cz.zujian?.id === resolved
Data.zujian?.id
);
case 'dingdan_chanpin'
:
return this.
data.dingdan_chanpins.some(dc =>
dc.dingdan?.id === resolved
Data.dingdan?.id &&
dc.chanpin?.id === resolved
Data.chanpin?.id
);
case 'dingdan_bancai'
:
return this.
data.dingdan_bancais.some(db =>
db.dingdan?.id === resolved
Data.dingdan?.id &&
db.chanpin?.id === resolved
Data.chanpin?.id &&
db.zujian?.id === resolved
Data.zujian?.id &&
db.bancai?.id === resolved
Data.bancai?.id
);
case 'user'
:
return this.
data.users.some(u => u.name === resolved
Data.name);
default
:
return false;
}
}
/**
* CRUD操作通用方法
*/
async crudOperation(operation, entity,
data) {
try {
// 使用微信请求API替代fetch
const result = await this.request(`/app/${operation}/${entity}`, '
POST',
data);
this.updateLocal
Data(operation, entity, result ||
data);
this.triggerCallbacks(operation, entity, result ||
data);
return result;
} catch (error) {
console.error('CRUD error
:', error);
this.triggerCallbacks(`${operation}_error`, entity, {
data, error
: error.message });
throw error;
}
}
/**
* 更新本地数据
* @param {string} operation - 操作类型
: 'add' | 'update' | 'delete'
* @param {string} entity - 实体名称
* @param {Object} new
Data - 新数据对象(包含id字段)
* @description 根据操作类型对本地数据进行增删改操作
*/
updateLocal
Data(operation, entity, new
Data) {
const key = `${entity}s`;
const entities = this._
rawData[key];
// 确保新数据的引用已解析
const resolved
Data = resolve
DataReference(new
Data, this._
rawData);
switch (operation) {
case 'add'
:
entities.push(resolved
Data);
break;
case 'update'
:
const
index = entities.find
Index(item => item.id === resolved
Data.id);
if (
index !== -1) {
// 修复：使用对象展开操作符确保属性完整覆盖
entities[
index] = { ...entities[
index], ...resolved
Data };
} else {
entities.push(resolved
Data);
}
break;
case 'delete'
:
const delete
Index = entities.find
Index(item => item.id === resolved
Data.id);
if (delete
Index !== -1) {
entities.splice(delete
Index, 1);
}
break;
}
// 更新最后修改时间
this._
rawData._lastModified = new Date().toISOString();
// 清除懒加载缓存
this.lazyLoader.clearCache();
// 保存修改后的数据到本地存储
this.save
DataToStorage();
}
/**
* 同步数据方法
* 该方法用于异步获取所有数据，并处理同步过程中的并发请求
* 如果同步正在进行中，会将请求标记为待处理(pendingSync)
* 同步完成后会自动处理待处理的请求
* @async
* @throws {Error} 当获取数据失败时会抛出错误并记录日志
*/
async sync
Data() {
if (this.isSyncing) {
this.pendingSync = true;
return;
}
this.isSyncing = true;
try {
// 1. 先加载本地数据
this.load
DataFromStorage();
// 2. 获取最后同步时间，用于增量更新
const since = this._
rawData._lastSync || null;
// 3. 获取增量数据
await this.fetchAll(since);
// 4. 清除懒加载缓存
this.lazyLoader.clearCache();
// 5. 保存更新后的数据到本地存储
this.save
DataToStorage();
// 6. 触发数据更新回调
this.triggerCallbacks('refresh', 'all', this.
data);
} catch (error) {
console.error('Sync failed
:', error);
this.triggerCallbacks('sync_error', 'all', { error });
// 失败时尝试使用本地数据
if (!this._
rawData._lastSync) {
throw new Error('初始化数据同步失败');
}
} finally {
this.isSyncing = false;
if (this.pendingSync) {
this.pendingSync = false;
this.sync
Data();
}
}
}
/**
* 从本地存储加载数据
* 使用微信小程序的同步存储API获取之前保存的数据
*/
load
DataFromStorage() {
try {
const stored
Data = wx.getStorageSync(this.storageKey);
if (stored
Data) {
// 修复：加载到_
rawData而非
data代理对象
this._
rawData = stored
Data;
// 解析所有引用关系
// resolve
DataReferences(this._
rawData);
}
} catch (error) {
console.error('加载本地存储数据失败
:', error);
// 提供默认空数据
this._
rawData = {
bancais
: [], dingdans
: [], mupis
: [], chanpins
: [], kucuns
: [],
dingdan_bancais
: [], chanpin_zujians
: [], zujians
: [], caizhis
: [],
dingdan_chanpins
: [], users
: [], jinhuos
: [],
_lastModified
: null, _lastSync
: null
};
}
}
/**
* 保存数据到本地存储
* 使用微信小程序的同步存储API持久化当前数据
*/
save
DataToStorage() {
try {
// 修复：保存_
rawData而非local
Data
wx.setStorageSync(this.storageKey, this._
rawData);
} catch (error) {
console.error('保存数据到本地存储失败
:', error);
// 提示用户或执行降级策略
wx.showToast({
title
: '数据保存失败，请稍后重试',
icon
: 'none'
});
}
}
/**
* 添加实体数据
* @async
* @param {string} entity - 实体类型
* @param {Object}
data - 要添加的实体数据
* @returns {Promise} 返回CRUD操作结果
* @throws {Error} 如果数据已存在则抛出错误
*/
async addEntity(entity,
data) {
if (this.checkDuplicate(entity,
data)) {
const errorMsg = `${this.entiyeText[entity]}`;
this.triggerCallbacks('duplicate_error', entity, {
data, error
: errorMsg });
throw new Error(errorMsg);
}
return this.crudOperation('add', entity,
data);
}
/**
* 更新实体
*/
async updateEntity(entity,
data) {
return this.crudOperation('update', entity,
data);
}
/**
* 删除实体
*/
async deleteEntity(entity, id) {
return this.crudOperation('delete', entity, { id });
}
getBancaisForZujian(zujianId) {
const dingdan_bancais = this.
data.dingdan_bancais.filter(db => db.zujian?.id == zujianId);
return dingdan_bancais.map(db => db.bancai).filter(Boolean);
}
/**
* 获取板材的库存信息
*/
getKucunForBancai(bancaiId) {
return this.
data.kucuns.find(k => k.bancai?.id == bancaiId);
}
/**
* 执行事务操作
* @param {string} endpoint - 事务接口的具体路径（例如：'kucunbianji'）
* @param {Object}
data - 发送给接口的数据
* @returns {Promise<boolean>} 操作是否成功
*/
async transactionalOperation(endpoint,
data) {
try {
// 发送请求到事务接口
await this.request(`/app/Transactional/${endpoint}`, '
POST',
data);
// 事务操作成功后，主动同步增量数据
await this.sync
Data();
// 返回成功
return true;
} catch (error) {
console.error(`事务操作失败 (${endpoint})
:`, error);
// 触发错误回调
this.triggerCallbacks('transaction_error', endpoint, {
data, error });
throw error;
}
}
/**
* 库存编辑事务操作
* @param {Object} kucun
Data - 库存编辑数据
* @returns {Promise<boolean>} 操作是否成功
*/
async kucunBianji(kucun
Data) {
return this.transactionalOperation('kucunbianji', kucun
Data);
}
}
// 导出模块
module.exports = MiniProgram
DataManager;简化优化代码量
本文介绍了一种改进的方法来获取PHP中的原始POST数据。通过使用条件操作符和file_get_contents函数，可以更灵活地处理HTTP_RAW_POST_DATA环境变量，确保即使在某些服务器配置下也能正确读取输入流。
扫一扫
202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
