// 解析数据引用关系的辅助函数
/**
* 解析数据中的引用关系
* 该函数用于处理嵌套的数据结构，将数据中的引用关系解析为实际的
对象引用。
* 它会遍历数据中的所有实体，查找属性名中包含的数字（如"item1"），
* 并尝试将这些属性
值替换为对应类型数据中的实际
对象引用。
* @param {Object} data - 包含嵌套引用的原始数据
对象
* @returns {Object} 处理后的数据
对象，其中引用已被解析为实际
对象
*/
function resolveDataReferences(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 resolveDataReference(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
.syncData
();
entity = (this
.dataManager
._rawData[refType] || [])
.find(e => e
.id === ref
.id);
}
if (entity) {
// 递归解析嵌套引用
const resolvedEntity = resolveDataReference({
...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 MiniProgramDataManager {
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
.loadDataFromStorage
();
this
.isSyncing = false;
this
.lastSync = null;
this
.c
allbacks = {
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 = 'miniProgramData'; // 本地存储的键名
}
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
.loadDataFromStorage
();
// 检查是否有本地数据
const hasLocalData = this
._rawData
._lastSync !== null;
console
.log('本地存储数据状态:', hasLocalData ? '有数据' : '无数据');
// 启动自动同步
this
.startAutoSync
();
//
执行首次数据同步
try {
await this
.syncData
();
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 (hasLocalData) {
console
.log('使用本地缓存数据');
return true;
}
throw error;
}
}
/**
* 启动自动同步定时器
* 每隔syncInterval毫秒检查并
执行数据同步
* 如果已有同步任务进行中则跳过
*/
startAutoSync
() {
if (this
.autoSyncTimer) clearInterval(this
.autoSyncTimer);
this
.autoSyncTimer = setInterval(
() => {
if (!this
.isSyncing) this
.syncData
();
}, 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 fetch
All(since) {
try {
console
.log(since ? `增量获取数据(自${since})
...` : '全量获取数据
...');
let resolvedData;
// 如果baseUrl为空，尝试加载本地测试数据
if (!this
.baseUrl) {
console
.log('使用本地测试数据');
try {
// 尝试从本地存储加载数据
this
.loadDataFromStorage
();
// 如果本地存储没有数据，尝试加载测试数据
if (!this
._rawData
._lastSync) {
console
.log('本地存储无数据，尝试加载测试数据');
// 创建测试数据
const testData = this
.createTestData
();
resolvedData = testData;
console
.log('已创建测试数据');
} else {
console
.log('使用本地存储的数据');
return true; // 已经从本地存储加载了数据
}
} catch (e) {
console
.error('加载本地测试数据失败:', e);
throw new Error('无法加载测试数据');
}
} else {
// 正常从API获取数据
const params = since ? { since } : {};
resolvedData = await this
.request('/app/
all', 'GET', params);
}
// 更新networkData
if (resolvedData) {
Object
.keys(this
._rawData)
.forEach(key => {
if (key
.startsWith('_')) return;
if (resolvedData[key]) {
if (since) {
// 增量更新: 合并新数据到现有数据
resolvedData[key]
.forEach(newItem => {
const index = this
._rawData[key]
.findIndex(item => item
.id === newItem
.id);
if (index >= 0) {
this
._rawData[key][index] = newItem;
} else {
this
._rawData[key]
.push(newItem);
}
});
} else {
// 全量更新: 直接替换
this
._rawData[key] = resolvedData[key];
}
}
});
}
// 更新同步时间
this
.lastSync = new Date
();
this
._rawData
._lastSync = this
.lastSync
.toISOString
();
// 保存到本地存储
this
.saveDataToStorage
();
this
.triggerC
allbacks('refresh', '
all', this
.data);
return true;
} catch (error) {
console
.error('Fetch error:', error);
this
.triggerC
allbacks('fetch_error', '
all', { error });
// 失败时尝试使用本地数据
if (!this
.lastSync) {
throw new Error('初始化数据获取失败');
}
return false;
}
}
// 创建测试数据
createTestData
() {
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 hasData = res
.data && (res
.data
.data !== undefined || typeof res
.data === 'object');
if (isSuccess && hasData) {
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);
}
/**
* 注册
回调函数
*/
registerC
allback(entity, c
allback) {
if (!this
.c
allbacks[entity]) {
this
.c
allbacks[entity] = [];
}
this
.c
allbacks[entity]
.push(c
allback);
}
/**
* 注销
回调函数
*/
unregisterC
allback(entity, c
allback) {
if (!this
.c
allbacks[entity]) return;
const index = this
.c
allbacks[entity]
.indexOf(c
allback);
if (index !== -1) {
this
.c
allbacks[entity]
.splice(index, 1);
}
}
/**
* 触发
回调函数
*/
triggerC
allbacks(operation, entity, data) {
this
.c
allbacks
.all.forEach(cb => cb(operation, entity, data));
if (this
.c
allbacks[entity]) {
this
.c
allbacks[entity]
.forEach(cb => cb(operation, data));
}
}
/**
* 检查重复实体
*/
checkDuplicate(entity, data) {
// 修复：确保引用已解析
const resolvedData = resolveDataReference(data, this
.data);
switch (entity) {
case 'bancai':
return this
.data
.bancais
.some(b =>
b
.houdu === resolvedData
.houdu &&
b
.caizhi?
.id === resolvedData
.caizhi?
.id &&
b
.mupi1?
.id === resolvedData
.mupi1?
.id &&
b
.mupi2?
.id === resolvedData
.mupi2?
.id
);
case 'caizhi':
return this
.data
.caizhis
.some(c => c
.name === resolvedData
.name);
case 'mupi':
return this
.data
.mupis
.some(m =>
m
.name === resolvedData
.name &&
m
.you === resolvedData
.you
);
case 'chanpin':
return this
.data
.chanpins
.some(c => c
.bianhao === resolvedData
.bianhao);
case 'zujian':
return this
.data
.zujians
.some(z => z
.name === resolvedData
.name);
case 'dingdan':
return this
.data
.dingdans
.some(d => d
.number === resolvedData
.number);
case 'chanpin_zujian':
return this
.data
.chanpin_zujians
.some(cz =>
cz
.chanpin?
.id === resolvedData
.chanpin?
.id &&
cz
.zujian?
.id === resolvedData
.zujian?
.id
);
case 'dingdan_chanpin':
return this
.data
.dingdan_chanpins
.some(dc =>
dc
.dingdan?
.id === resolvedData
.dingdan?
.id &&
dc
.chanpin?
.id === resolvedData
.chanpin?
.id
);
case 'dingdan_bancai':
return this
.data
.dingdan_bancais
.some(db =>
db
.dingdan?
.id === resolvedData
.dingdan?
.id &&
db
.chanpin?
.id === resolvedData
.chanpin?
.id &&
db
.zujian?
.id === resolvedData
.zujian?
.id &&
db
.bancai?
.id === resolvedData
.bancai?
.id
);
case 'user':
return this
.data
.users
.some(u => u
.name === resolvedData
.name);
default:
return false;
}
}
/**
* CRUD操作通用方法
*/
async crudOperation(operation, entity, data) {
try {
// 使用微信请求API替代fetch
const result = await this
.request(`/app/${operation}/${entity}`, 'POST', data);
this
.updateLocalData(operation, entity, result || data);
this
.triggerC
allbacks(operation, entity, result || data);
return result;
} catch (error) {
console
.error('CRUD error:', error);
this
.triggerC
allbacks(`${operation}_error`, entity, { data, error: error
.message });
throw error;
}
}
/**
* 更新本地数据
* @param {string} operation - 操作类型: 'add' | 'update' | 'delete'
* @param {string} entity - 实体名称
* @param {Object} newData - 新数据
对象(包含id字段)
* @description 根据操作类型对本地数据进行增删改操作
*/
updateLocalData(operation, entity, newData) {
const key = `${entity}s`;
const entities = this
._rawData[key];
// 确保新数据的引用已解析
const resolvedData = resolveDataReference(newData, this
._rawData);
switch (operation) {
case 'add':
entities
.push(resolvedData);
break;
case 'update':
const index = entities
.findIndex(item => item
.id === resolvedData
.id);
if (index !== -1) {
// 修复：使用
对象展开操作符确保属性完整覆盖
entities[index] = {
...entities[index],
...resolvedData };
} else {
entities
.push(resolvedData);
}
break;
case 'delete':
const deleteIndex = entities
.findIndex(item => item
.id === resolvedData
.id);
if (deleteIndex !== -1) {
entities
.splice(deleteIndex, 1);
}
break;
}
// 更新最后修改时间
this
._rawData
._lastModified = new Date
().toISOString
();
// 清除懒加载缓存
this
.lazyLoader
.clearCache
();
// 保存修改后的数据到本地存储
this
.saveDataToStorage
();
}
/**
* 同步数据方法
* 该方法用于异步获取所有数据，并处理同步过程中的并发请求
* 如果同步正在进行中，会将请求标记为待处理(pendingSync)
* 同步完成后会自动处理待处理的请求
* @async
* @throws {Error} 当获取数据失败时会抛出错误并记录日志
*/
async syncData
() {
if (this
.isSyncing) {
this
.pendingSync = true;
return;
}
this
.isSyncing = true;
try {
// 1
. 先加载本地数据
this
.loadDataFromStorage
();
// 2
. 获取最后同步时间，用于增量更新
const since = this
._rawData
._lastSync || null;
// 3
. 获取增量数据
await this
.fetch
All(since);
// 4
. 清除懒加载缓存
this
.lazyLoader
.clearCache
();
// 5
. 保存更新后的数据到本地存储
this
.saveDataToStorage
();
// 6
. 触发数据更新
回调
this
.triggerC
allbacks('refresh', '
all', this
.data);
} catch (error) {
console
.error('Sync failed:', error);
this
.triggerC
allbacks('sync_error', '
all', { error });
// 失败时尝试使用本地数据
if (!this
._rawData
._lastSync) {
throw new Error('初始化数据同步失败');
}
} fin
ally {
this
.isSyncing = false;
if (this
.pendingSync) {
this
.pendingSync = false;
this
.syncData
();
}
}
}
/**
* 从本地存储加载数据
* 使用微信小程序的同步存储API获取之前保存的数据
*/
loadDataFromStorage
() {
try {
const storedData = wx
.getStorageSync(this
.storageKey);
if (storedData) {
// 修复：加载到_rawData而非data代理
对象
this
._rawData = storedData;
// 解析所有引用关系
// resolveDataReferences(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持久化当前数据
*/
saveDataToStorage
() {
try {
// 修复：保存_rawData而非localData
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
.triggerC
allbacks('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);
}
}
// 导出模块
module
.exports = MiniProgramDataManager;----添加专门处理服务端事务接口package com
.kucun
.controller;
import org
.springframework
.beans
.factory
.annotation
.Autowired;
import org
.springframework
.web
.bind
.annotation
.RequestMapping;
import org
.springframework
.web
.bind
.annotation
.RestController;
import com
.kucun
.Service
.BancaiService;
import com
.kucun
.data
.entity
.Information;
import org
.springframework
.web
.bind
.annotation
.RequestMethod;
import org
.springframework
.web
.bind
.annotation
.RequestParam;
@RestController
@RequestMapping("/app/Transactional")
public class TransactionalController{
@Autowired
private BancaiService bancaiService;
@RequestMapping(value = "/kucunbianji", method = RequestMethod
.GET)
public Information requestMethodName(@RequestParam Integer banciId, @RequestParam Integer shuliang, @RequestParam Integer userId) {
bancaiService
.updateKucunAndCreateJinhuo(banciId, shuliang, userId);
return Information
.NewSuccess(null);
}
}
扫一扫
1466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
