{
+ return {
+ key: target.abstractSpace.key,
+ item: target.abstractSpace,
+ label: target.name,
+ itemType: target.abstractSpace.typeName,
+ menus: loadFileMenus(target.abstractSpace),
+ tag: [target.typeName],
+ icon:
,
+ children: children,
+ };
+};
+
+/** 编译空间树 */
+const buildSpaceTree = (
+ spaces: IAbstractSpace[],
+ typeNames: string[],
+): MenuItemType[] => {
+ return spaces.map((space) => {
+ let children: MenuItemType[] = [];
+ if (space.typeName === '空间') {
+ children = buildSpaceTree(space.children, typeNames);
+ }
+ return {
+ key: space.key,
+ item: space,
+ label: space.name,
+ tag: [space.typeName],
+ icon:
,
+ itemType: space.typeName,
+ menus: loadFileMenus(space),
+ children: children,
+ };
+ });
+};
+
+/** 获取个人菜单 */
+const getSpaceMenu = (directory: IDirectory, typeNames: string[]) => {
+ return createMenu(
+ directory.target,
+ buildSpaceTree(directory.target.abstractSpace.children, typeNames),
+ );
+};
+
+/** 加载设置模块菜单 */
+export const loadSettingMenu = (
+ directory: IDirectory,
+ typeNames?: string[] | undefined,
+) => {
+ if (!typeNames) {
+ typeNames = ['人员', '单位', '空间', '仓储空间'];
+ }
+ const rootMenu: MenuItemType = getSpaceMenu(directory, typeNames);
+ return rootMenu;
+};
diff --git a/src/components/OpenSpaceDialog/content/index.tsx b/src/components/OpenSpaceDialog/content/index.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..7703fc7740a30ee1ba0e8cfa5e73a95ef5198b47
--- /dev/null
+++ b/src/components/OpenSpaceDialog/content/index.tsx
@@ -0,0 +1,116 @@
+import React, { useEffect, useState } from 'react';
+import DirectoryViewer from '@/components/Directory/views';
+import useCtrlUpdate from '@/hooks/useCtrlUpdate';
+import { IAbstractSpace } from '@/ts/core';
+import { loadFileMenus } from '@/executor/fileOperate';
+import { command } from '@/ts/base';
+import orgCtrl from '@/ts/controller';
+import useAsyncLoad from '@/hooks/useAsyncLoad';
+import { Spin } from 'antd';
+import { cleanMenus } from '@/utils/tools';
+import { ISpace } from '@/ts/core/abstractSpace/abstractSpaceInfo';
+
+interface IProps {
+ accepts?: string[];
+ selects?: ISpace[];
+ excludeIds?: string[];
+ current: IAbstractSpace | 'disk';
+ spaceContents?: ISpace[];
+ onFocused?: (file: ISpace | undefined) => void;
+ onSelected?: (files: ISpace[]) => void;
+ showFile?: boolean;
+}
+/**
+ * 空间
+ */
+const Space: React.FC
= (props) => {
+ if (!props.current) return <>;
+ const [space] = useState(
+ props.current === 'disk' ? orgCtrl.user.abstractSpace : props.current,
+ );
+ const [key] = useCtrlUpdate(space);
+ const [currentTag, setCurrentTag] = useState('全部');
+ const [loaded] = useAsyncLoad(() => space.loadContent(false));
+ const [focusFile, setFocusFile] = useState();
+ useEffect(() => {
+ command.emitter('preview', 'dialog', focusFile);
+ }, [focusFile]);
+
+ const contextMenu = (file?: ISpace) => {
+ const entity = file ?? space;
+ return {
+ items: cleanMenus(loadFileMenus(entity)) || [],
+ onClick: ({ key }: { key: string }) => {
+ command.emitter('executor', key, entity, space.key);
+ },
+ };
+ };
+
+ const selectHanlder = (file: ISpace, selected: boolean) => {
+ if (props.selects && props.onSelected) {
+ if (selected) {
+ props.onSelected([...props.selects, file]);
+ } else {
+ props.onSelected(props.selects.filter((i) => i.key !== file.key));
+ }
+ }
+ };
+
+ const fileFocused = (file: ISpace | undefined) => {
+ if (file) {
+ if (focusFile && file.key === focusFile.key) {
+ return true;
+ }
+ return props.selects?.find((i) => i.key === file.key) !== undefined;
+ }
+ return false;
+ };
+
+ const clickHanlder = (file: ISpace | undefined) => {
+ // if(file.tag)
+ const focused = fileFocused(file);
+ if (focused) {
+ setFocusFile(undefined);
+ props.onFocused?.apply(this, [undefined]);
+ } else {
+ setFocusFile(file);
+ props.onFocused?.apply(this, [file]);
+ }
+ if (file && props.onSelected) {
+ selectHanlder(file, !focused);
+ }
+ };
+
+ const getContent = () => {
+ const contents: ISpace[] = [];
+ if (props.current === 'disk') {
+ contents.push(
+ orgCtrl.user.abstractSpace,
+ ...orgCtrl.user.companys.map((i) => i.abstractSpace),
+ );
+ } else {
+ contents.push(...props.current!.content(props.showFile));
+ }
+ return contents;
+ };
+
+ return (
+
+ setCurrentTag(t)}
+ fileOpen={(entity) => clickHanlder(entity as ISpace)}
+ contextMenu={(entity) => contextMenu(entity as ISpace)}
+ />
+
+ );
+};
+export default Space;
diff --git a/src/components/OpenSpaceDialog/index.tsx b/src/components/OpenSpaceDialog/index.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..d2817c3fa67aa8d3ab422728038ddce385bf641a
--- /dev/null
+++ b/src/components/OpenSpaceDialog/index.tsx
@@ -0,0 +1,101 @@
+import React, { useState } from 'react';
+import MainLayout from '../MainLayout';
+import Content from './content';
+import useMenuUpdate from '@/hooks/useMenuUpdate';
+import FullScreenModal from '../Common/fullScreen';
+import { Button, Divider, Space } from 'antd';
+import orgCtrl, { Controller } from '@/ts/controller';
+import { MenuItemType } from 'typings/globelType';
+import { ISpace } from '@/ts/core/abstractSpace/abstractSpaceInfo';
+import { IDirectory } from '@/ts/core';
+import { loadSettingMenu } from './config';
+
+export interface ISpaceDialogProps {
+ directory: IDirectory;
+ typeNames?: string[];
+ title?: string;
+ accepts: string[];
+ spaceContents?: ISpace[];
+ onOk: (files: ISpace[]) => void;
+ onCancel: () => void;
+ leftShow?: boolean;
+ rightShow?: boolean;
+ showFile?: boolean;
+ multiple?: boolean;
+ maxCount?: number;
+ excludeIds?: string[];
+ onSelectMenuChanged?: (menu: MenuItemType) => void;
+}
+
+const OpenSpaceDialog: React.FC = (props) => {
+ const [selectedSpaces, setSelectedSpaces] = useState([]);
+ const [key, rootMenu, selectMenu, setSelectMenu] = useMenuUpdate(() => {
+ return loadSettingMenu(props.directory);
+ }, new Controller(orgCtrl.currentKey));
+ if (!selectMenu || !rootMenu) return <>;
+ return (
+ {
+ props.onCancel();
+ setSelectedSpaces([]);
+ }}
+ destroyOnClose
+ width={'80vw'}
+ bodyHeight={'70vh'}
+ footer={
+ } wrap size={2}>
+
+
+ }>
+ {
+ setSelectMenu(data);
+ props.onSelectMenuChanged?.apply(this, [data]);
+ }}
+ siderMenuData={rootMenu}>
+ {
+ if (!props.multiple) {
+ if (space) {
+ setSelectedSpaces([space]);
+ } else {
+ setSelectedSpaces([]);
+ }
+ }
+ }}
+ onSelected={(spaces) => {
+ if (props.multiple) {
+ if (props.maxCount && spaces.length > props.maxCount) {
+ setSelectedSpaces(spaces.slice(-props.maxCount));
+ } else {
+ setSelectedSpaces(spaces);
+ }
+ }
+ }}
+ />
+
+
+ );
+};
+
+export default OpenSpaceDialog;
diff --git a/src/components/Space/components/canvas.tsx b/src/components/Space/components/canvas.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..2f71def4d1d14309580314fdbd11f201bc510563
--- /dev/null
+++ b/src/components/Space/components/canvas.tsx
@@ -0,0 +1,104 @@
+import React, { useState, useRef } from 'react';
+import style from '@/components/Space/less/index.module.less';
+import { XGoodsShelves, XWareHousingSpace } from '@/ts/base/schema';
+interface IProps {
+ warehouse: XWareHousingSpace;
+ scale: number;
+ renderShelf: (shelf: XGoodsShelves) => JSX.Element;
+ addNewShelf: (e: React.MouseEvent) => void;
+ activeTool: string;
+}
+// 画布组件
+const Canvas: React.FC = ({
+ warehouse,
+ scale,
+ renderShelf,
+ addNewShelf,
+ activeTool,
+}) => {
+ // 拖拽状态管理
+ const [isDragging, setIsDragging] = useState(false);
+ const [panOffset, setPanOffset] = useState({ x: 0, y: 0 });
+ const dragStartRef = useRef({ x: 0, y: 0 });
+ const containerRef = useRef(null);
+ const canvasRef = useRef(null);
+
+ // 计算网格尺寸（随缩放比例变化）
+ const gridSize = 50 * scale;
+
+ // 处理鼠标按下事件（开始拖拽）
+ const handleMouseDown = (e: React.MouseEvent) => {
+ if (activeTool === 'hand' && e.button === 0) {
+ // 仅左键拖拽
+ setIsDragging(true);
+ dragStartRef.current = {
+ x: e.clientX - panOffset.x,
+ y: e.clientY - panOffset.y,
+ };
+ e.preventDefault(); // 防止文本选中
+ }
+ };
+
+ // 处理鼠标移动事件（拖拽中）
+ const handleMouseMove = (e: React.MouseEvent) => {
+ if (isDragging) {
+ const newX = e.clientX - dragStartRef.current.x;
+ const newY = e.clientY - dragStartRef.current.y;
+
+ setPanOffset({
+ x: newX,
+ y: newY,
+ });
+ }
+ };
+
+ // 处理鼠标释放事件（结束拖拽）
+ const handleMouseUp = () => {
+ setIsDragging(false);
+ };
+
+ // 处理点击事件（添加货架）
+ const handleClick = (e: React.MouseEvent) => {
+ // 拖拽操作时不添加货架
+ if (!isDragging && activeTool === 'shelf') {
+ addNewShelf(e);
+ }
+ };
+
+ // 动态光标样式
+ const getCursorStyle = () => {
+ if (isDragging) return 'grabbing';
+ if (activeTool === 'shelf') return 'crosshair';
+ if (activeTool === 'hand') return 'grab';
+ return 'default';
+ };
+
+ return (
+
+
+ {warehouse?.goodsShelves?.map(renderShelf)}
+
+
+
+
+
{warehouse.name}
+
+
+
+ {tools.map((tool) => (
+
handleToolSelect(tool.id)}
+ title={tool.name}>
+ {tool.icon}
+
+ ))}
+
+
+
+ 缩放: {(scale * 100).toFixed(0)}%
+
+
+ 货架: {warehouse.goodsShelves?.length}
+
+ {/*
*/}
+ {/* 库位: {inventory.totalSlots}*/}
+ {/*
*/}
+
*/}
+ {/* */}
+ {/*
*/}
+
+ );
+};
+
+export default Header;
diff --git a/src/components/Space/components/rightPanel.tsx b/src/components/Space/components/rightPanel.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..127b78d52dcf5418a46404c2c75311fa0bd4cb43
--- /dev/null
+++ b/src/components/Space/components/rightPanel.tsx
@@ -0,0 +1,34 @@
+import React from 'react';
+import style from '@/components/Space/less/index.module.less';
+import ShelfProperties from './shelfProperties';
+import WarehouseOverview from './warehouseOverview';
+import { XGoodsShelves } from '@/ts/base/schema';
+import { IWareHousing } from '@/ts/core/abstractSpace/standard/warehousing';
+import { IGoodsShelvesSlot } from '@/ts/core/abstractSpace/standard/goodsShelvesSlot';
+interface IProps {
+ selectedShelf: XGoodsShelves | undefined;
+ updateShelf: (shelfId: string, updates: Partial) => void;
+ slots: IGoodsShelvesSlot[];
+ warehouse: IWareHousing;
+ //inventory: ReturnType;
+}
+// 右侧面板组件
+const RightPanel: React.FC = ({
+ selectedShelf,
+ updateShelf,
+ slots,
+ warehouse,
+ //inventory,
+}) => {
+ return (
+
+ {selectedShelf ? (
+
+ ) : (
+ //inventory={inventory} />
+ )}
+
+ );
+};
+
+export default RightPanel;
diff --git a/src/components/Space/components/shelfProperties.tsx b/src/components/Space/components/shelfProperties.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..62158bab7cc8be5641f5fdac9e59c442897d6692
--- /dev/null
+++ b/src/components/Space/components/shelfProperties.tsx
@@ -0,0 +1,267 @@
+import React, { useState, useEffect } from 'react';
+import style from '@/components/Space/less/index.module.less';
+import { XGoodsShelves } from '@/ts/base/schema';
+import SlotGridView from '@/components/Space/components/slotGridView';
+import { Button } from 'antd';
+import { FaEdit, FaSave } from 'react-icons/fa';
+import SlotEditModal from '@/components/Space/components/soleEditModal';
+import { IGoodsShelvesSlot } from '@/ts/core/abstractSpace/standard/goodsShelvesSlot';
+
+interface IProps {
+ slots: IGoodsShelvesSlot[];
+ shelf: XGoodsShelves;
+ updateShelf: (shelfId: string, updates: Partial) => void;
+}
+
+// 货架属性组件
+const ShelfProperties: React.FC = ({ slots, shelf, updateShelf }) => {
+ const [selectedSlot, setSelectedSlot] = useState(null);
+ const [formData, setFormData] = useState({
+ name: shelf.name,
+ code: shelf.code,
+ positionX: shelf.position[0],
+ positionY: shelf.position[1],
+ width: shelf.width,
+ length: shelf.length,
+ rows: shelf.rows,
+ cols: shelf.cols,
+ });
+ const [isEditing, setIsEditing] = useState(false);
+
+ // 当货架属性变化时更新表单数据
+ useEffect(() => {
+ setFormData({
+ name: shelf.name,
+ code: shelf.code,
+ positionX: shelf.position[0],
+ positionY: shelf.position[1],
+ width: shelf.width,
+ length: shelf.length,
+ rows: shelf.rows,
+ cols: shelf.cols,
+ });
+ }, [shelf]);
+
+ // 处理表单字段变化
+ const handleInputChange = (field: keyof typeof formData, value: any) => {
+ setFormData((prev) => ({ ...prev, [field]: value }));
+ };
+
+ // 保存所有货架信息
+ const saveShelfInfo = () => {
+ updateShelf(shelf.id, {
+ name: formData.name,
+ code: formData.code,
+ position: [formData.positionX, formData.positionY],
+ width: formData.width,
+ length: formData.length,
+ rows: formData.rows,
+ cols: formData.cols,
+ });
+ setIsEditing(false);
+ };
+
+ // 处理库位点击
+ const handleSlotClick = (slot: IGoodsShelvesSlot) => {
+ setSelectedSlot(slot);
+ };
+
+ // 取消编辑
+ const cancelEdit = () => {
+ setFormData({
+ name: shelf.name,
+ code: shelf.code,
+ positionX: shelf.position[0],
+ positionY: shelf.position[1],
+ width: shelf.width,
+ length: shelf.length,
+ rows: shelf.rows,
+ cols: shelf.cols,
+ });
+ setIsEditing(false);
+ };
+
+ return (
+
+ {selectedSlot && (
+
setSelectedSlot(null)}
+ />
+ )}
+
+
+
+
货架信息
+ {isEditing ? (
+
+ }
+ onClick={saveShelfInfo}
+ className={style.save_button}>
+ 保存
+
+
+
+ ) : (
+
}
+ onClick={() => setIsEditing(true)}
+ className={style.edit_button}>
+ 编辑
+
+ )}
+
+
+
+
+ {isEditing ? (
+
+ handleInputChange('name', e.target.value)}
+ />{' '}
+
+ ) : (
+
{shelf.name}
+ )}
+
+
+
+
+ {isEditing ? (
+
+ handleInputChange('code', e.target.value)}
+ />{' '}
+
+ ) : (
+
{shelf.code}
+ )}
+
+
+
+
+ {isEditing ? (
+
+
+ handleInputChange('positionX', parseFloat(e.target.value) || 0)
+ }
+ />
+
+ handleInputChange('positionY', parseFloat(e.target.value) || 0)
+ }
+ />
+
+ ) : (
+
+ {shelf.position[0].toFixed(2)}, {shelf.position[1].toFixed(2)}
+
+ )}
+
+
+
+
+ {isEditing ? (
+
+
+ handleInputChange('length', parseFloat(e.target.value) || 1)
+ }
+ />
+
+ handleInputChange('width', parseFloat(e.target.value) || 1)
+ }
+ />
+
+ ) : (
+
+ {shelf.length.toFixed(2)}× {shelf.width.toFixed(2)}
+
+ )}
+
+
+
+
+ {isEditing ? (
+
+ handleInputChange('rows', parseInt(e.target.value) || 0)}
+ />
+ handleInputChange('cols', parseInt(e.target.value) || 0)}
+ />
+
+ ) : (
+
+ {shelf.rows} × {shelf.cols}
+
+ )}
+
+
+ {grid.map((row, rowIndex) => (
+
+ {row.map((slot) => {
+ const utilization =
+ slot.metadata.capacity > 0
+ ? Math.round(
+ ((slot.metadata?.inventory?.length ?? 0) / slot.metadata.capacity) *
+ 100,
+ )
+ : 0;
+
+ let bgColor = '#e8f5e9'; // 空闲
+ if (utilization > 90) bgColor = '#ffcdd2'; // 已满
+ else if (utilization > 70) bgColor = '#ffe0b2'; // 警告
+ else if (utilization > 0) bgColor = '#c8e6c9'; // 使用中
+
+ const isEmpty = slot.metadata.capacity === 0;
+
+ return (
+
!isEmpty && onSlotClick(slot)}>
+ {!isEmpty && (
+
+
{slot.metadata.name}
+
{utilization}%
+
+ )}
+
+ );
+ })}
+
+ ))}
+
+
仓库概览
+
+
+
+
仓库名称
+
{warehouse.metadata.name}
+
+
+
仓库地址
+
{warehouse.metadata.address}
+
+
+
仓库尺寸
+
+ {warehouse.metadata.length}m × {warehouse.metadata.width}m
+
+
+
+
货架数量
+
{warehouse.shelves?.length}
+
+
+
库位总容量
+
{warehouse.totalSlotsCapacity}
+
+
+
库位使用容量
+
+ {warehouse.usedSlotsCapacity}/{warehouse.totalSlotsCapacity}
+
+
+
+
库位使用率
+
{warehouse.utilization}%
+
+
+
90
+ ? '#f44336'
+ : warehouse.utilization > 70
+ ? '#ff9800'
+ : '#4caf50',
+ }}>
+ {warehouse.utilization >= 10 ? `${warehouse.utilization}%` : ''}
+
+
+
+
handleShelfDragStart(shelf.id, e)}>
+
{shelf.name}
+
+
+
+
+
+
+ {dataSource.map((thing) => (
+
+
+ {thing.id}
+ {/*物资名称：{thing.id}*/}
+
+ }
+ value={thing.id}
+ key={thing.id}
+ // description={
+ //
+ //
+ // {thing.code}
+ //
+ //
+ // }
+ />
+
+ ))}
+
+
+ );
+ };
+ return (
+ {
+ if (slot) {
+ let result: boolean = false;
+ switch (tableProps.formType) {
+ case 'addToInventory':
+ result = await tableProps.current.AddToInventory(
+ slot,
+ select.map((item) => item.id),
+ );
+ break;
+ case 'removeFromInventory':
+ modalTitle = '下架';
+ result = await tableProps.current.RemoveFromInventory(
+ slot,
+ select.map((item) => item.id),
+ );
+ break;
+ default:
+ return;
+ }
+ if (result) {
+ logger.info(`${modalTitle}成功`);
+ if (tableProps.formType === 'removeFromInventory') {
+ await loadThings();
+ }
+ } else {
+ //logger.error(`${modalTitle}失败`);
+ }
+ }
+ }}
+ onCancel={props.finished}
+ okButtonProps={{ disabled: select?.length < 1 }}
+ width={670}>
+
+ {
+ if (!value || !Array.isArray(value) || !value[1]) {
+ setSlot(undefined);
+ return;
+ }
+ try {
+ const slot = tableProps.current.shelvesSlots.find(
+ (item) => item.id === value[1],
+ );
+ if (!slot) {
+ setSlot(undefined);
+ return;
+ }
+ setSlot(slot.id);
+ } catch (error) {
+ setSlot(undefined);
+ }
+ }}
+ />
+ {modalTitle === '上架' ? (
+ {
+ setSearchKey(event.target.value);
+ }}
+ />
+ ) : (
+ <>
+ )}
+ {dataSource.length > 0 && infoList()}
+ {searchKey && dataSource.length == 0 && (
+ } title={`抱歉，没有查询到相关的结果`} />
+ )}
+
+
+ );
+};
+
+export default InventoryFrom;
diff --git a/src/components/Space/search/index.module.less b/src/components/Space/search/index.module.less
new file mode 100644
index 0000000000000000000000000000000000000000..d9d41b3e7464099e815f0f1009a2f955d7c87577
--- /dev/null
+++ b/src/components/Space/search/index.module.less
@@ -0,0 +1,47 @@
+@import (reference) '~antd/es/style/themes/variable';
+
+:global {
+ .ogo-avatar-lg {
+ width: 60px;
+ height: 60px;
+ line-height: 60px;
+ border-radius: 50%;
+ }
+}
+
+.search-card {
+ min-height: 300px;
+ // background-color: @item-hover-bg;
+ padding: 24px;
+ .card {
+ width: 306px;
+ margin-top: 24px;
+ .description {
+ margin-top: @margin-xs;
+ }
+ }
+
+ .company-select-type {
+ border: 1px solid #5ba0e7;
+ }
+
+ .company-no-select-type {
+ border: 1px solid #000;
+ }
+}
+
+.tree-title-wrapper {
+ display: flex;
+
+ .tree-title-icon {
+ margin-top: 2px;
+ margin-right: 5px;
+ }
+}
+.dept-tree{
+ :global{
+ .ogo-tree-node-content-wrapper.ogo-tree-node-selected{
+ background-color: #bdd7ff;
+ }
+ }
+}
diff --git a/src/components/Space/tool.ts b/src/components/Space/tool.ts
new file mode 100644
index 0000000000000000000000000000000000000000..23ab26495820b529a22b355ce376d5a58e3b4efa
--- /dev/null
+++ b/src/components/Space/tool.ts
@@ -0,0 +1,5 @@
+export type Tool = {
+ id: string;
+ name: string;
+ icon: JSX.Element;
+};
diff --git a/src/executor/action.tsx b/src/executor/action.tsx
index 170b3d3b1746b422fe0b6e77c468745a545eabeb..3b5227eb80b8fc98cf8356c6679ce9ba748a09f7 100644
--- a/src/executor/action.tsx
+++ b/src/executor/action.tsx
@@ -1,5 +1,6 @@
import React, { useEffect, useRef, useState } from 'react';
import {
+ IAbstractSpace,
IApplication,
IDirectory,
IEntity,
@@ -33,8 +34,10 @@ import MemberBox from '@/components/DataStandard/WorkForm/Viewer/customItem/memb
import { IVersion } from '@/ts/core/thing/standard/version';
import { $confirm } from '@/utils/react/antd';
import { IReception } from '@/ts/core/work/assign/reception';
+import { ISpace } from '@/ts/core/abstractSpace/abstractSpaceInfo';
/** 执行非页面命令 */
export const executeCmd = (cmd: string, entity: any) => {
+ console.log(cmd);
switch (cmd) {
case 'qrcode':
return entityQrCode(entity);
@@ -129,7 +132,10 @@ export const executeCmd = (cmd: string, entity: any) => {
};
/** 刷新目录 */
-const directoryRefresh = (dir: IDirectory | IApplication, reload: boolean) => {
+const directoryRefresh = (
+ dir: IDirectory | IApplication | IAbstractSpace,
+ reload: boolean,
+) => {
dir.loadContent(reload).then(() => {
orgCtrl.changCallback();
});
@@ -413,7 +419,7 @@ const openChat = (entity: IMemeber | ITarget | ISession) => {
};
/** 恢复实体 */
-const restoreEntity = (entity: IFile) => {
+const restoreEntity = (entity: IFile | ISpace) => {
entity.restore().then((success: boolean) => {
if (success) {
orgCtrl.changCallback();
@@ -422,7 +428,7 @@ const restoreEntity = (entity: IFile) => {
};
/** 删除实体 */
-const deleteEntity = (entity: IFile, hardDelete: boolean) => {
+const deleteEntity = (entity: IFile | ISpace, hardDelete: boolean) => {
Modal.confirm({
okText: '确认',
cancelText: '取消',
diff --git a/src/executor/operate/entityForm/index.tsx b/src/executor/operate/entityForm/index.tsx
index 85a475496a83760923ad437856e19d00fdbc4abc..7ed26b5eb2f4814f39a382f179bbdc66219599a2 100644
--- a/src/executor/operate/entityForm/index.tsx
+++ b/src/executor/operate/entityForm/index.tsx
@@ -22,6 +22,10 @@ import DocumentTemplateForm from './DocumentTemplateForm';
import ReportForm from './reportForm';
import AssignTaskModelForm from '@/executor/operate/entityForm/assignTaskModelForm';
import ReportTaskForm from './reportTaskForm';
+import SpaceForm from '@/executor/operate/entityForm/spaceForm';
+import WareHousingForm from '@/executor/operate/entityForm/warehousingSpaceForm';
+import InventoryForm from '@/components/Space/search/InventoryForm';
+
interface IProps {
cmd: string;
entity: IEntity;
@@ -45,6 +49,19 @@ const EntityForm: React.FC = ({ cmd, entity, finished }) => {
);
}
+ case 'newSpace':
+ case 'updateSpace':
+ return ;
+ case 'newWareHousing':
+ case 'updateWareHousing':
+ return (
+
+ );
+ case 'addToInventory':
+ case 'removeFromInventory':
+ return (
+
+ );
case 'newApp':
case 'newModule':
case 'updateApp':
diff --git a/src/executor/operate/entityForm/propertyForm.tsx b/src/executor/operate/entityForm/propertyForm.tsx
index cf05d1987e740fd4bbe703e83a4b8af0f2b7dad7..4dee832bdc62f4f24afa62ebafc4897994e74abf 100644
--- a/src/executor/operate/entityForm/propertyForm.tsx
+++ b/src/executor/operate/entityForm/propertyForm.tsx
@@ -5,6 +5,7 @@ import { IDirectory, valueTypes, IProperty } from '@/ts/core';
import { EntityColumns } from './entityColumns';
import { schema } from '@/ts/base';
import OpenFileDialog from '@/components/OpenFileDialog';
+import OpenSpaceDialog from '@/components/OpenSpaceDialog';
import { Input } from 'antd';
interface Iprops {
@@ -127,6 +128,29 @@ const PropertyForm = (props: Iprops) => {
},
});
}
+ if (['空间型'].includes(selectType || '')) {
+ const typeName = '空间';
+ columns.push({
+ title: `选择${typeName}`,
+ dataIndex: 'speciesId',
+ valueType: 'select',
+ formItemProps: { rules: [{ required: true, message: `${typeName}为必填项` }] },
+ renderFormItem() {
+ if (readonly) {
+ return {species?.name ?? ''}
;
+ }
+ return (
+ setNeedType(typeName)}
+ />
+ );
+ },
+ });
+ }
if (selectType === '引用型') {
columns.push({
title: `选择表单`,
@@ -225,13 +249,14 @@ const PropertyForm = (props: Iprops) => {
props.finished();
}}
/>
- {needType !== '' && (
+ {needType !== '' && needType != '空间' && (
setNeedType('')}
onOk={(files) => {
+ console.log(needType)
if (['字典', '分类'].includes(needType)) {
if (files.length > 0) {
setSpecies(files[0].metadata);
@@ -249,6 +274,22 @@ const PropertyForm = (props: Iprops) => {
}}
/>
)}
+ {needType !== '' && needType === '空间' && (
+ setNeedType('')}
+ onOk={(files) => {
+ if (files.length > 0) {
+ setSpecies(files[0].metadata);
+ } else {
+ setSpecies(undefined);
+ }
+ setNeedType('');
+ }}
+ />
+ )}
);
};
diff --git a/src/executor/operate/entityForm/spaceForm.tsx b/src/executor/operate/entityForm/spaceForm.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..e04afc71f586f66cf1b26024dc83014766cecd90
--- /dev/null
+++ b/src/executor/operate/entityForm/spaceForm.tsx
@@ -0,0 +1,128 @@
+import React, { useRef } from 'react';
+import { ProFormColumnsType, ProFormInstance } from '@ant-design/pro-components';
+import SchemaForm from '@/components/SchemaForm';
+import { IAbstractSpace } from '@/ts/core';
+import { EntityColumns } from './entityColumns';
+import { schema } from '@/ts/base';
+import { generateCodeByInitials } from '@/utils/tools';
+
+interface Iprops {
+ formType: string;
+ current: IAbstractSpace;
+ finished: () => void;
+}
+/*
+ 编辑
+*/
+const SpaceForm = (props: Iprops) => {
+ let title = '';
+ const readonly = props.formType === 'remarkSpace';
+ let initialValue: any = props.current.metadata;
+ const formRef = useRef();
+ switch (props.formType) {
+ case 'newSpace':
+ title = '新建空间';
+ initialValue = { shareId: props.current.target.id };
+ break;
+ case 'updateSpace':
+ title = '更新空间';
+ break;
+ case 'remarkSpace':
+ title = '查看空间';
+ break;
+ default:
+ return <>;
+ }
+ const columns: ProFormColumnsType[] = [
+ {
+ title: '名称',
+ dataIndex: 'name',
+ readonly: readonly,
+ formItemProps: {
+ rules: [{ required: true, message: '名称为必填项' }],
+ },
+ },
+ {
+ title: '代码',
+ dataIndex: 'code',
+ readonly: readonly,
+ formItemProps: {
+ rules: [{ required: true, message: '代码为必填项' }],
+ },
+ },
+ {
+ title: '地址',
+ dataIndex: 'address',
+ colProps: { span: 24 },
+ readonly: readonly,
+ formItemProps: {
+ rules: [{ required: true, message: '地址信息为必填项' }],
+ },
+ },
+ {
+ title: '制定组织',
+ dataIndex: 'shareId',
+ valueType: 'select',
+ hideInForm: true,
+ readonly: readonly,
+ formItemProps: { rules: [{ required: true, message: '组织为必填项' }] },
+ fieldProps: {
+ options: [
+ {
+ value: props.current.target.id,
+ label: props.current.target.name,
+ },
+ ],
+ },
+ },
+ ];
+ if (readonly) {
+ columns.push(...EntityColumns(props.current.metadata));
+ }
+ columns.push({
+ title: '备注信息',
+ dataIndex: 'remark',
+ valueType: 'textarea',
+ colProps: { span: 24 },
+ readonly: readonly,
+ formItemProps: {
+ rules: [{ required: true, message: '备注信息为必填项' }],
+ },
+ });
+ return (
+
+ formRef={formRef}
+ open
+ title={title}
+ width={640}
+ columns={columns}
+ initialValues={initialValue}
+ rowProps={{
+ gutter: [24, 0],
+ }}
+ layoutType="ModalForm"
+ onOpenChange={(open: boolean) => {
+ if (!open) {
+ props.finished();
+ }
+ }}
+ onValuesChange={async (values: any) => {
+ if (Object.keys(values)[0] === 'name') {
+ formRef.current?.setFieldValue('code', generateCodeByInitials(values['name']));
+ }
+ }}
+ onFinish={async (values) => {
+ switch (props.formType) {
+ case 'updateSpace':
+ await props.current.update(values);
+ break;
+ case 'newSpace':
+ await props.current.create(values);
+ break;
+ }
+ props.finished();
+ }}>
+ );
+};
+
+export default SpaceForm;
diff --git a/src/executor/operate/entityForm/warehousingSpaceForm.tsx b/src/executor/operate/entityForm/warehousingSpaceForm.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..326a46563062932897ba505fa8ecd899127f433c
--- /dev/null
+++ b/src/executor/operate/entityForm/warehousingSpaceForm.tsx
@@ -0,0 +1,144 @@
+import React, { useRef } from 'react';
+import { ProFormColumnsType, ProFormInstance } from '@ant-design/pro-components';
+import SchemaForm from '@/components/SchemaForm';
+import { IAbstractSpace } from '@/ts/core';
+import { EntityColumns } from './entityColumns';
+import { schema } from '@/ts/base';
+import { generateCodeByInitials } from '@/utils/tools';
+import { IWareHousing } from '@/ts/core/abstractSpace/standard/warehousing';
+
+interface Iprops {
+ formType: string;
+ current: IAbstractSpace | IWareHousing;
+ finished: () => void;
+}
+/*
+ 编辑
+*/
+const WareHousingForm = (props: Iprops) => {
+ let title = '';
+ let abstractSpace: IAbstractSpace;
+ let wareHousing: IWareHousing | undefined;
+ const readonly = props.formType === 'remarkWareHousing';
+ let initialValue: any = props.current.metadata;
+ const formRef = useRef();
+ switch (props.formType) {
+ case 'newWareHousing':
+ title = '新建仓储空间';
+ abstractSpace = props.current as IAbstractSpace;
+ initialValue = {};
+ break;
+ case 'updateWareHousing':
+ wareHousing = props.current as IWareHousing;
+ abstractSpace = wareHousing.abstractSpace;
+ title = '更新' + wareHousing.typeName;
+ break;
+ case 'remarkWareHousing':
+ wareHousing = props.current as IWareHousing;
+ abstractSpace = wareHousing.abstractSpace;
+ title = '查看' + wareHousing.typeName;
+ break;
+ default:
+ return <>;
+ }
+ const columns: ProFormColumnsType[] = [
+ {
+ title: '名称',
+ dataIndex: 'name',
+ readonly: readonly,
+ formItemProps: {
+ rules: [{ required: true, message: '名称为必填项' }],
+ },
+ },
+ {
+ title: '代码',
+ dataIndex: 'code',
+ readonly: readonly,
+ formItemProps: {
+ rules: [{ required: true, message: '代码为必填项' }],
+ },
+ },
+ {
+ title: '长(m)',
+ dataIndex: 'length',
+ readonly: readonly,
+ valueType: 'digit',
+ fieldProps: {
+ min: 0,
+ },
+ formItemProps: {
+ rules: [{ required: true, message: '长(m)为必填项' }],
+ },
+ },
+ {
+ title: '宽(m)',
+ dataIndex: 'width',
+ readonly: readonly,
+ valueType: 'digit',
+ fieldProps: {
+ min: 0,
+ },
+ formItemProps: {
+ rules: [{ required: true, message: '宽(m)为必填项' }],
+ },
+ },
+ {
+ title: '地址',
+ dataIndex: 'address',
+ readonly: readonly,
+ colProps: { span: 24 },
+ formItemProps: {
+ rules: [{ required: true, message: '地址信息为必填项' }],
+ },
+ },
+ ];
+ if (readonly) {
+ columns.push(...EntityColumns(props.current.metadata));
+ }
+ columns.push({
+ title: '备注信息',
+ dataIndex: 'remark',
+ valueType: 'textarea',
+ colProps: { span: 24 },
+ readonly: readonly,
+ formItemProps: {
+ rules: [{ required: true, message: '备注信息为必填项' }],
+ },
+ });
+ return (
+
+ formRef={formRef}
+ open
+ title={title}
+ width={640}
+ columns={columns}
+ initialValues={initialValue}
+ rowProps={{
+ gutter: [24, 0],
+ }}
+ layoutType="ModalForm"
+ onOpenChange={(open: boolean) => {
+ if (!open) {
+ props.finished();
+ }
+ }}
+ onValuesChange={async (values: any) => {
+ if (Object.keys(values)[0] === 'name') {
+ formRef.current?.setFieldValue('code', generateCodeByInitials(values['name']));
+ }
+ }}
+ onFinish={async (values) => {
+ switch (props.formType) {
+ case 'updateWareHousing':
+ await wareHousing!.update(values);
+ break;
+ case 'newWareHousing':
+ await abstractSpace.standard.createWareHousing(values);
+ break;
+ }
+ props.finished();
+ }}>
+ );
+};
+
+export default WareHousingForm;
diff --git a/src/executor/operate/index.tsx b/src/executor/operate/index.tsx
index 44d7c91926971d49265815ec26da67ffe1bed823..516a47ec7d5a894abfb3d3d7646c4b319ff997c4 100644
--- a/src/executor/operate/index.tsx
+++ b/src/executor/operate/index.tsx
@@ -76,17 +76,31 @@ const ConfigExecutor: React.FC = ({ cmd, args, finished }) => {
if (
entity.groupTags &&
entity.groupTags.some((item) =>
- ['视图', '表单', '报表', '表格'].includes(item),
+ ['视图', '表单', '报表', '表格', '空间', '仓储空间'].includes(item),
)
) {
- if (entity.typeName === '表格') {
- return (
-
- );
- } else {
- return (
-
- );
+ console.log(entity.typeName);
+ switch (entity.typeName) {
+ case '表格':
+ return (
+
+ );
+ case '空间':
+ return (
+
+ );
+ case '仓储空间':
+ return (
+
+ );
+ default:
+ return (
+
+ );
}
}
if (Object.keys(entityMap).includes(args[0].typeName)) {
diff --git a/src/executor/tools/uploadItem.tsx b/src/executor/tools/uploadItem.tsx
index 939567a92e32d4dd70dda155fbfe444324f5c4e9..d11218f93ee977fb88927f60f83a8d0f86fe28d7 100644
--- a/src/executor/tools/uploadItem.tsx
+++ b/src/executor/tools/uploadItem.tsx
@@ -1,13 +1,14 @@
import React, { useState } from 'react';
import { model, parseAvatar } from '@/ts/base';
import { message, Upload, UploadProps, Image, Button, Space, Avatar } from 'antd';
-import { IDirectory } from '@/ts/core';
+import { IDirectory, IAbstractSpace } from '@/ts/core';
import TypeIcon from '@/components/Common/GlobalComps/typeIcon';
+import { IWareHousing } from '@/ts/core/abstractSpace/standard/warehousing';
interface IProps {
icon?: string;
typeName: string;
- directory: IDirectory;
+ directory: IDirectory | IAbstractSpace | IWareHousing;
readonly?: boolean;
avatarSize?: number;
iconSize?: number;
@@ -42,7 +43,7 @@ const UploadItem: React.FC = ({
async customRequest(options) {
const file = options.file as File;
if (file) {
- const result = await directory.createFile(file.name, file);
+ const result = await directory?.createFile(file.name, file);
if (result) {
setAvatar(result.shareInfo());
onChanged(JSON.stringify(result.shareInfo()));
diff --git a/src/pages/Home/components/SpaceBrowser/index.tsx b/src/pages/Home/components/SpaceBrowser/index.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..207bd78f43dbf1f9391abef2e38ab2ab23aa5cb9
--- /dev/null
+++ b/src/pages/Home/components/SpaceBrowser/index.tsx
@@ -0,0 +1,105 @@
+import React, { useEffect, useState } from 'react';
+import { command } from '@/ts/base';
+import DirectoryViewer from '@/components/Directory/views';
+import { loadFileMenus } from '@/executor/fileOperate';
+import { Spin } from 'antd';
+import { cleanMenus } from '@/utils/tools';
+import { ISpace, IStandardSpaceInfo } from '@/ts/core/abstractSpace/abstractSpaceInfo';
+import AppLayout from '@/components/MainLayout/appLayout';
+import useTimeoutHanlder from '@/hooks/useTimeoutHanlder';
+
+interface IProps {
+ root: IStandardSpaceInfo;
+}
+
+/**
+ * @description: 默认目录
+ * @return {*}
+ */
+const SpaceBrowser: React.FC = ({ root }) => {
+ const [currentTag, setCurrentTag] = useState('全部');
+ const [preDirectory, setPreDirectory] = useState();
+ const [directory, setDirectory] = useState(root);
+ const [content, setContent] = useState(directory.content());
+ const [loaded, setLoaded] = useState(false);
+ const [focusFile, setFocusFile] = useState();
+ const [submitHanlder] = useTimeoutHanlder();
+ useEffect(() => {
+ if (loaded) {
+ command.emitter('preview', 'space', focusFile);
+ }
+ }, [focusFile, loaded]);
+ useEffect(() => {
+ setDirectory(root);
+ }, [root]);
+ useEffect(() => {
+ if (content.length > 0) {
+ setFocusFile(content[0]);
+ }
+ }, [content]);
+ useEffect(() => {
+ setCurrentTag('全部');
+ const id = directory.subscribe(() => {
+ loadContent(directory, directory, false);
+ });
+ if (directory != root) {
+ setPreDirectory(directory.superior);
+ } else {
+ setPreDirectory(undefined);
+ }
+ return () => {
+ directory.unsubscribe(id);
+ };
+ }, [directory]);
+ /** 加载目录内容 */
+ const loadContent = (file: ISpace, directory: ISpace, reload: boolean) => {
+ setLoaded(false);
+ file.loadContent(reload).then(async () => {
+ const data = directory.content();
+ if (file.key === directory.key) {
+ setLoaded(true);
+ setContent(data);
+ }
+ });
+ };
+ const focusHanlder = (file: ISpace | undefined) => {
+ if (file && file.key !== focusFile?.key) {
+ setFocusFile(file);
+ }
+ };
+ const contextMenu = (file?: ISpace) => {
+ const entity = file ?? directory;
+ return {
+ items: cleanMenus(loadFileMenus(entity)) || [],
+ onClick: ({ key }: { key: string }) => {
+ command.emitter('executor', key, entity);
+ },
+ };
+ };
+
+ return (
+
+
+ setCurrentTag(t)}
+ fileOpen={(file) => {
+ if (file && 'isContainer' in file && file.isContainer) {
+ setDirectory(file as IStandardSpaceInfo);
+ } else {
+ submitHanlder(() => focusHanlder(file as ISpace), 300);
+ }
+ }}
+ preDirectory={preDirectory}
+ contextMenu={(entity) => contextMenu(entity as ISpace)}
+ />
+
+
+ );
+};
+export default SpaceBrowser;
diff --git a/src/pages/Home/index.tsx b/src/pages/Home/index.tsx
index a9906a049fcf37e55abd0fddd27b254f2a6b32c2..9be12b3e4472b82ff5865722ae50f2b294b97e04 100644
--- a/src/pages/Home/index.tsx
+++ b/src/pages/Home/index.tsx
@@ -19,6 +19,7 @@ import ChatViewer from './components/ChatViewer';
import RelationBrowser from './components/RelationBrowser';
import TargetsActivity from './components/TargetsActivity';
import TaskViewer from './components/TaskViewer';
+import SpaceBrowser from '@/pages/Home/components/SpaceBrowser';
const defaultActions = [
{ text: '首页', icon: 'homebar/home', count: 0, bodyType: 'home' },
@@ -29,6 +30,7 @@ const defaultActions = [
{ text: '文档', icon: 'homebar/store', count: 0, bodyType: 'file' },
{ text: '应用', icon: 'homebar/store', count: 0, bodyType: 'data' },
{ text: '关系', icon: 'homebar/relation', count: 0, bodyType: 'relation' },
+ { text: '空间', icon: 'homebar/relation', count: 0, bodyType: 'abstractSpace' },
];
const Home: React.FC = () => {
const [bodyType, setBodyType] = useState('bench');
@@ -224,6 +226,9 @@ const Home: React.FC = () => {
return ;
case 'activity':
return ;
+ case 'abstractSpace':
+ console.log(orgCtrl.home.current.abstractSpace);
+ return ;
default:
if (typeof bodyType === 'string') {
return (
diff --git a/src/ts/base/schema.ts b/src/ts/base/schema.ts
index 240923a2be9c71748da8368f5ded56cf2bccd798..8bcb0cadcb65fb5fc92ee10c9eb78d464112fb4e 100644
--- a/src/ts/base/schema.ts
+++ b/src/ts/base/schema.ts
@@ -1844,3 +1844,71 @@ export interface viewEntity {
avatar?: FileItemShare;
};
}
+export type XAbstractSpaceStandard = {
+ //空间id
+ abstractSpaceId: string;
+ //是否删除
+ isDeleted: boolean;
+ //二维平面长宽
+ length: number;
+ width: number;
+ height?: number;
+ address?: string;
+ //位置
+ position?: [number, number];
+} & XEntity;
+
+//抽象空间
+export type XAbstractSpace = {
+ //权限ids
+ applyAuths: string[];
+} & XAbstractSpaceStandard;
+//仓储空间
+export type XWareHousingSpace = {
+ [key: string]: any;
+ //货架信息
+ goodsShelves: XGoodsShelves[];
+} & XAbstractSpaceStandard;
+//货架
+export type XGoodsShelves = {
+ //货架id
+ id: string;
+ //货架名称
+ name: string;
+ //货架编号
+ code: string;
+ //二维平面长宽
+ length: number;
+ width: number;
+ height?: number;
+ //货架行数列数
+ rows: number;
+ cols: number;
+ //货架坐标位置
+ position: [number, number];
+};
+
+//库位
+export type XGoodsShelvesSlot = {
+ [key: string]: any;
+ wareHousingId: string;
+ //归属货架
+ goodsShelveId: string;
+ //容量
+ capacity: number;
+ //库存
+ inventory: string[];
+} & XAbstractSpaceStandard;
+
+// 变更历史
+export interface XShelvesSlotRecord extends XEntity {
+ // 操作
+ operate: string;
+ wareHousingId: string;
+ //归属货架
+ goodsShelveId: string;
+ //库位
+ goodsShelvesSlotId: string;
+ //物资
+ goodsId: string;
+}
diff --git a/src/ts/core/abstractSpace/abstractSpace.ts b/src/ts/core/abstractSpace/abstractSpace.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1dd31d61c594a455a864e1f1ad34e6ae27968f72
--- /dev/null
+++ b/src/ts/core/abstractSpace/abstractSpace.ts
@@ -0,0 +1,168 @@
+import { model, schema } from '../../base';
+import { ITarget } from '@/ts/core';
+import { DataResource } from '@/ts/core/thing/resource';
+import { StandardAbstractSpaces } from '@/ts/core/abstractSpace/standard';
+import { spaceOperates } from '@/ts/core/public';
+import { ISpace, IStandardSpaceInfo, StandardSpaceInfo } from './abstractSpaceInfo';
+export interface IAbstractSpace extends IStandardSpaceInfo {
+ /** 真实的空间Id */
+ abstractSpaceId: string;
+ standard: StandardAbstractSpaces;
+ /** 当前的用户 */
+ target: ITarget;
+ /** 资源类 */
+ resource: DataResource;
+ /** 上级 */
+ parent: IAbstractSpace | undefined;
+ /** 下级 */
+ children: IAbstractSpace[];
+ /** 是否有权限 */
+ isAuth: boolean;
+ /** 空间下的内容 */
+ content(store?: boolean): ISpace[];
+ /** 创建空间 */
+ create(data: schema.XAbstractSpace): Promise;
+
+ loadSpaceResource(reload?: boolean): Promise;
+}
+export class AbstractSpace
+ extends StandardSpaceInfo
+ implements IAbstractSpace
+{
+ constructor(
+ _metadata: schema.XAbstractSpace,
+ _target: ITarget,
+ _parent?: IAbstractSpace,
+ _spaces?: schema.XAbstractSpace[],
+ ) {
+ super(
+ {
+ ..._metadata,
+ typeName: _metadata.typeName || '空间',
+ },
+ _target.resource.abstractSpaceColl,
+ );
+ this.parent = _parent;
+ this.target = _target;
+ this.standard = new StandardAbstractSpaces(this);
+ }
+ target: ITarget;
+ standard: StandardAbstractSpaces;
+ parent: IAbstractSpace | undefined;
+ get children(): IAbstractSpace[] {
+ return this.standard.abstractSpaces;
+ }
+ get isContainer(): boolean {
+ return true;
+ }
+ get isShortcut(): boolean {
+ return false;
+ }
+ get groupTags(): string[] {
+ let tags: string[] = [];
+ if (this.parent) {
+ tags = [...super.groupTags];
+ } else {
+ tags = [this.target.typeName];
+ }
+ return tags;
+ }
+ get resource(): DataResource {
+ return this.target.resource;
+ }
+ get abstractSpaceId(): string {
+ return this.id;
+ }
+ get isAuth(): boolean {
+ if (!this._metadata.applyAuths?.length || this._metadata.applyAuths[0] === '0')
+ return true;
+ return this.target.hasAuthoritys(this._metadata.applyAuths);
+ }
+ get cacheFlag(): string {
+ return 'abstractSpaces';
+ }
+ get superior(): ISpace {
+ return this.parent ?? this.target.abstractSpace;
+ }
+ get id(): string {
+ if (!this.parent) {
+ return this.target.id;
+ }
+ return super.id;
+ }
+
+ content(_store: boolean = false): ISpace[] {
+ const cnt: ISpace[] = [...this.children];
+ cnt.push(...this.standard.wareHousings);
+ return cnt.sort((a, b) => (a.metadata.updateTime < b.metadata.updateTime ? 1 : -1));
+ }
+ async loadContent(reload: boolean = false): Promise {
+ if (reload) {
+ await this.loadSpaceResource(reload);
+ }
+ await this.standard.loadStandardSpaces(reload);
+ return true;
+ }
+ public async loadSpaceResource(reload: boolean = false) {
+ if (this.parent === undefined || reload) {
+ await this.resource.preSpaceLoad(reload);
+ }
+ await this.standard.loadSpaces(reload);
+ await this.standard.loadWareHousings(reload);
+ }
+ async create(data: schema.XAbstractSpace): Promise {
+ const result = await this.resource.abstractSpaceColl.insert({
+ ...data,
+ abstractSpaceId: this.id,
+ });
+ if (result) {
+ await this.notify('insert', result);
+ return result;
+ }
+ }
+
+ override async delete(): Promise {
+ if (this.parent) {
+ await this.resource.abstractSpaceColl.delete(this.metadata);
+ await this.notify('delete', this.metadata);
+ }
+ return false;
+ }
+ override async hardDelete(): Promise {
+ if (this.parent) {
+ await this.resource.abstractSpaceColl.remove(this.metadata);
+ await this.recursionDelete(this);
+ await this.notify('reload', this.metadata);
+ }
+ return false;
+ }
+ private async recursionDelete(_space: IAbstractSpace) {
+ if (!this.isShortcut) {
+ for (const child of _space.children) {
+ await this.recursionDelete(child);
+ }
+ await _space.standard.delete();
+ }
+ }
+ // 右键操作
+ override operates(): model.OperateModel[] {
+ const operates: model.OperateModel[] = [];
+ operates.push(spaceOperates.Refesh);
+ if (this.target.hasRelationAuth()) {
+ operates.push(spaceOperates.NewSpace);
+ }
+ if (this.parent) {
+ operates.push(spaceOperates.NewWareHousingSpace);
+ operates.push(...super.operates());
+ }
+ return operates;
+ }
+
+ override receive(operate: string, data: schema.XAbstractSpaceStandard): boolean {
+ console.log(operate, data);
+ this.coll.removeCache((i) => i.id != data.id);
+ super.receive(operate, data);
+ this.coll.cache.push(this._metadata);
+ return true;
+ }
+}
diff --git a/src/ts/core/abstractSpace/abstractSpaceInfo.ts b/src/ts/core/abstractSpace/abstractSpaceInfo.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ef39b5d6fb0cf5f86356d12f4a1c7a5d004420e1
--- /dev/null
+++ b/src/ts/core/abstractSpace/abstractSpaceInfo.ts
@@ -0,0 +1,142 @@
+import { sleep } from '@/ts/base/common';
+import { model, schema } from '../../base';
+import { Entity, entityOperates, IEntity } from '../public';
+import { XCollection } from '@/ts/core';
+
+/** 默认空间接口 */
+export interface ISpace extends ISpaceInfo {}
+/** 空间类接口 */
+export interface ISpaceInfo extends IEntity {
+ /** 上级 */
+ superior: ISpace;
+ /** 删除文件系统项 */
+ delete(notity?: boolean): Promise;
+ /** 彻底删除文件系统项 */
+ hardDelete(notity?: boolean): Promise;
+ /**
+ * 重命名
+ * @param {string} name 新名称
+ */
+ rename(name: string): Promise;
+ /** 加载文件内容 */
+ loadContent(reload: boolean): Promise;
+
+ /** 目录下的内容 */
+ content(args?: boolean): ISpace[];
+}
+/** 文件类抽象实现 */
+export abstract class SpaceInfo
+ extends Entity
+ implements ISpaceInfo
+{
+ constructor(_metadata: T) {
+ super(_metadata, [_metadata.typeName]);
+ }
+ override get metadata(): T {
+ return this._metadata;
+ }
+ get superior(): ISpace {
+ return this;
+ }
+ abstract delete(): Promise;
+ abstract hardDelete(): Promise;
+ async rename(_: string): Promise {
+ await sleep(0);
+ return true;
+ }
+ async restore(): Promise {
+ await sleep(0);
+ return true;
+ }
+
+ async loadContent(reload: boolean = false): Promise {
+ return await sleep(reload ? 10 : 0);
+ }
+ content(): ISpace[] {
+ return [];
+ }
+}
+
+export interface IStandardSpaceInfo<
+ T extends schema.XAbstractSpaceStandard = schema.XAbstractSpaceStandard,
+> extends ISpaceInfo {
+ /** 设置当前元数据 */
+ setMetadata(_metadata: schema.XAbstractSpaceStandard): void;
+ /** 变更通知 */
+ notify(operate: string, data: T): Promise;
+ /** 更新 */
+ update(data: T): Promise;
+ /** 接收通知 */
+ receive(operate: string, data: schema.XAbstractSpaceStandard): boolean;
+}
+export interface IStandard extends IStandardSpaceInfo {}
+export abstract class StandardSpaceInfo
+ extends SpaceInfo
+ implements IStandardSpaceInfo
+{
+ coll: XCollection;
+ constructor(_metadata: T, _coll: XCollection) {
+ super(_metadata);
+ this.coll = _coll;
+ }
+ override get metadata(): T {
+ return this._metadata;
+ }
+ async update(data: T): Promise {
+ const result = await this.coll.replace({
+ ...this.metadata,
+ ...data,
+ abstractSpaceId: this.metadata.abstractSpaceId,
+ typeName: this.metadata.typeName,
+ });
+ if (result) {
+ this.notify('replace', result);
+ return true;
+ }
+ return false;
+ }
+ async delete(notify: boolean = true): Promise {
+ const data = await this.coll.delete(this.metadata);
+ if (data && notify) {
+ await this.notify('delete', this.metadata);
+ }
+ return false;
+ }
+ async hardDelete(notify: boolean = true): Promise {
+ const data = await this.coll.remove(this.metadata);
+ if (data && notify) {
+ await this.notify('remove', this.metadata);
+ }
+ return false;
+ }
+ async restore(): Promise {
+ return this.update({ ...this.metadata, isDeleted: false });
+ }
+ async rename(name: string): Promise {
+ return await this.update({ ...this.metadata, name });
+ }
+ override operates(): model.OperateModel[] {
+ const operates: model.OperateModel[] = [];
+ operates.unshift(entityOperates.Update, entityOperates.HardDelete);
+ return operates;
+ }
+ async notify(operate: string, data: T): Promise {
+ return await this.coll.notity({ data, operate });
+ }
+ receive(operate: string, data: schema.XAbstractSpaceStandard): boolean {
+ switch (operate) {
+ case 'delete':
+ case 'replace':
+ if (data) {
+ if (operate === 'delete') {
+ data = { ...data, isDeleted: true } as unknown as T;
+ this.setMetadata(data as T);
+ } else {
+ this.setMetadata(data as T);
+ this.loadContent(true);
+ }
+ }
+ }
+ return true;
+ }
+}
diff --git a/src/ts/core/abstractSpace/standard/goodsShelvesSlot.ts b/src/ts/core/abstractSpace/standard/goodsShelvesSlot.ts
new file mode 100644
index 0000000000000000000000000000000000000000..de636f6ec4c917ccfbcbffefdf9b1b5ec8a8c676
--- /dev/null
+++ b/src/ts/core/abstractSpace/standard/goodsShelvesSlot.ts
@@ -0,0 +1,134 @@
+import { schema } from '../../../base';
+import {
+ IStandardSpaceInfo,
+ StandardSpaceInfo,
+} from '@/ts/core/abstractSpace/abstractSpaceInfo';
+import { IAbstractSpace, ITarget } from '@/ts/core';
+import { DataResource } from '@/ts/core/thing/resource';
+import { IWareHousing } from '@/ts/core/abstractSpace/standard/warehousing';
+import { logger } from '@/ts/base/common';
+//库位
+export interface IGoodsShelvesSlot extends IStandardSpaceInfo {
+ /** 当前的用户 */
+ target: ITarget;
+ /** 资源集合 */
+ resource: DataResource;
+ abstractSpace: IAbstractSpace;
+ wareHousing: IWareHousing;
+
+ /** 上架 */
+ AddToInventory(thingId: string[]): Promise;
+ /** 下架 */
+ RemoveFromInventory(thingId: string[]): Promise;
+ /** 加载物品 */
+ loadThing(code?: string): Promise;
+}
+
+export class GoodsShelvesSlot
+ extends StandardSpaceInfo
+ implements IGoodsShelvesSlot
+{
+ constructor(
+ _metadata: schema.XGoodsShelvesSlot,
+ _space: IAbstractSpace,
+ _wareHousing: IWareHousing,
+ ) {
+ super(_metadata, _space.resource.goodsShelvesSlotColl);
+ this.setEntity();
+ this.abstractSpace = _space;
+ this.wareHousing = _wareHousing;
+ this.target = _space.target;
+ this.resource = _space.resource;
+ //this.currentStock = this._metadata.inventory.length ?? 0;
+ }
+ abstractSpace: IAbstractSpace;
+ resource: DataResource;
+ target: ITarget;
+ wareHousing: IWareHousing;
+ //currentStock: number;
+ get id(): string {
+ return this._metadata.id.replace('_', '');
+ }
+ get superior(): IWareHousing {
+ return this.wareHousing;
+ }
+ get cacheFlag(): string {
+ return 'shelvesSlots';
+ }
+ /** 上架 */
+ async AddToInventory(thingId: string[]): Promise {
+ if (
+ this._metadata.capacity <
+ (this._metadata.inventory?.length ?? 0) + thingId.length
+ ) {
+ logger.warn(`库位${this._metadata.name}已满。`);
+ return false;
+ }
+ if (!this._metadata.inventory) {
+ this._metadata.inventory = [];
+ }
+ this._metadata.inventory.push(...thingId);
+ const result = await this.coll.update(this.id, {
+ _set_: this._metadata,
+ });
+ if (result) {
+ await this.notify('replace', result);
+ return true;
+ }
+ // const result = await this.coll.replace({
+ // ...this.metadata,
+ // });
+ // if (result) {
+ // await this.notify('remove', this.metadata);
+ // await this.abstractSpace.resource.goodsShelvesSlotColl.notity({
+ // data: result,
+ // operate: 'insert',
+ // });
+ // return true;
+ // }
+ return false;
+ }
+ /** 下架 */
+ async RemoveFromInventory(thingId: string[]): Promise {
+ this._metadata.inventory = this._metadata.inventory.filter(
+ (id) => !thingId.includes(id),
+ );
+ console.log(this._metadata.inventory);
+ const result = await this.coll.update(this.id, {
+ _set_: this._metadata,
+ });
+ if (result) {
+ this.notify('replace', result);
+ return true;
+ }
+ return false;
+ }
+ async loadThing(code?: string): Promise {
+ if (code) {
+ const res = await this.resource.thingColl.loadResult({
+ options: {
+ match: {
+ id: code,
+ isDeleted: false,
+ },
+ project: {
+ archives: 0,
+ },
+ },
+ });
+ return res.data ?? [];
+ }
+ const res = await this.resource.thingColl.loadResult({
+ options: {
+ match: {
+ id: { _in_: this._metadata.inventory },
+ isDeleted: false,
+ },
+ project: {
+ archives: 0,
+ },
+ },
+ });
+ return res.data ?? [];
+ }
+}
diff --git a/src/ts/core/abstractSpace/standard/index.ts b/src/ts/core/abstractSpace/standard/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b7f3abffa1d19ebd1efad4288ebbe61433020e43
--- /dev/null
+++ b/src/ts/core/abstractSpace/standard/index.ts
@@ -0,0 +1,229 @@
+import { schema } from '../../../base';
+import { DataResource } from '@/ts/core/thing/resource';
+import { AbstractSpace, IAbstractSpace } from '@/ts/core/abstractSpace/abstractSpace';
+import { IStandard } from '@/ts/core/abstractSpace/abstractSpaceInfo';
+import { IWareHousing, WareHousing } from '@/ts/core/abstractSpace/standard/warehousing';
+import { IGoodsShelvesSlot } from '@/ts/core/abstractSpace/standard/goodsShelvesSlot';
+
+export class StandardAbstractSpaces {
+ /** 空间对象 */
+ abstractSpace: IAbstractSpace;
+ /** 空间 */
+ abstractSpaces: IAbstractSpace[] = [];
+ wareHousings: IWareHousing[] = [];
+ goodsShelvesSlots: IGoodsShelvesSlot[] = [];
+ /** 加载完成标志 */
+ spaceLoaded: boolean = false;
+ wareHousingLoaded: boolean = false;
+ goodsShelvesSlotLoaded: boolean = false;
+ constructor(_abstractSpace: IAbstractSpace) {
+ this.abstractSpace = _abstractSpace;
+ if (this.abstractSpace.parent === undefined) {
+ subscribeNotity(this.abstractSpace);
+ }
+ }
+ get id(): string {
+ return this.abstractSpace.abstractSpaceId;
+ }
+ get resource(): DataResource {
+ return this.abstractSpace.resource;
+ }
+
+ get standardSpaces(): IStandard[] {
+ return [...this.wareHousings, ...this.abstractSpaces];
+ }
+
+ async loadStandardSpaces(reload: boolean = false): Promise {
+ await Promise.all([this.loadWareHousings(reload)]);
+ return this.standardSpaces as IStandard[];
+ }
+ async loadSpaces(reload: boolean = false): Promise {
+ if (!this.spaceLoaded || reload) {
+ this.spaceLoaded = true;
+ var spaces = this.resource.abstractSpaceColl.cache.filter(
+ (i) => i.abstractSpaceId === this.id,
+ );
+ this.abstractSpaces = spaces.map(
+ (a) => new AbstractSpace(a, this.abstractSpace.target, this.abstractSpace),
+ );
+ for (const space of this.abstractSpaces) {
+ await space.standard.loadSpaces();
+ }
+ }
+ return this.abstractSpaces;
+ }
+
+ // async loadGoodsShelvesSlot(reload: boolean = false): Promise {
+ // if (!this.goodsShelvesSlotLoaded || reload) {
+ // this.goodsShelvesSlotLoaded = true;
+ // this.goodsShelvesSlots = this.resource.goodsShelvesSlotColl.cache
+ // .filter((i) => i.abstractSpaceId === this.id)
+ // .map((i) => {
+ // return new GoodsShelvesSlot(i, this.abstractSpace);
+ // });
+ // // this.wareHousings = this.xWareHousings
+ // // .filter((a) => !(a.parentId && a.parentId.length > 5))
+ // // .map((i) => {
+ // // return new WareHousing(i, this.abstractSpace);
+ // // });
+ // }
+ // return this.wareHousings;
+ // }
+
+ async loadWareHousings(reload: boolean = false): Promise {
+ if (!this.wareHousingLoaded || reload) {
+ this.wareHousingLoaded = true;
+ this.wareHousings = this.resource.wareHousingSpaceColl.cache
+ .filter((i) => i.abstractSpaceId === this.id)
+ .map((i) => {
+ return new WareHousing(i, this.abstractSpace);
+ });
+ // this.wareHousings = this.xWareHousings
+ // .filter((a) => !(a.parentId && a.parentId.length > 5))
+ // .map((i) => {
+ // return new WareHousing(i, this.abstractSpace);
+ // });
+ }
+ return this.wareHousings;
+ }
+ async createWareHousing(
+ data: schema.XWareHousingSpace,
+ ): Promise {
+ const result = await this.resource.wareHousingSpaceColl.insert({
+ ...data,
+ typeName: '仓储空间',
+ abstractSpaceId: this.id,
+ });
+ if (result) {
+ await this.resource.wareHousingSpaceColl.notity({
+ data: result,
+ operate: 'insert',
+ });
+ return result;
+ }
+ }
+
+ async delete() {
+ await Promise.all(this.standardSpaces.map((item) => item.hardDelete()));
+ }
+}
+/** 订阅变更通知 */
+const subscribeNotity = (space: IAbstractSpace) => {
+ space.resource.abstractSpaceColl.subscribe([space.key], (data) => {
+ subscribeCallback(space, '空间', data);
+ });
+ space.resource.wareHousingSpaceColl.subscribe([space.key], (data) => {
+ subscribeCallback(space, '仓储空间', data);
+ });
+ space.resource.goodsShelvesSlotColl.subscribe([space.key], (data) => {
+ subscribeCallback(space, '库位', data);
+ });
+};
+
+/** 订阅回调方法 */
+function subscribeCallback(
+ space: IAbstractSpace,
+ typeName: string,
+ data?: { operate?: string; data?: T },
+): boolean {
+ if (data && data.operate && data.data) {
+ const entity = data.data;
+ const operate = data.operate;
+ if (space.id === entity.abstractSpaceId) {
+ if (
+ ['库位'].includes(entity.typeName) ||
+ ('wareHousingId' in entity && (entity as any).wareHousingId)
+ ) {
+ for (const app of space.standard.wareHousings) {
+ if (app.receive(operate, entity)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ switch (operate) {
+ case 'insert':
+ case 'remove':
+ standardSpaceChanged(space, typeName, operate, entity);
+ break;
+ case 'reload':
+ space.loadContent(true).then(() => {
+ space.changCallback();
+ });
+ return true;
+ default:
+ space.standard.standardSpaces
+ .find((i) => i.id === entity.id)
+ ?.receive(operate, entity);
+ break;
+ }
+ space.changCallback();
+ return true;
+ }
+ for (const subspace of space.standard.abstractSpaces) {
+ if (subscribeCallback(subspace, typeName, data)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+/** 空间的变更 */
+function standardSpaceChanged(
+ space: IAbstractSpace,
+ typeName: string,
+ operate: string,
+ data: any,
+): void {
+ console.log(typeName);
+ switch (typeName) {
+ case '空间':
+ space.standard.abstractSpaces = ArrayChanged(
+ space.standard.abstractSpaces,
+ operate,
+ data,
+ () => new AbstractSpace(data, space.target, space),
+ );
+ if (operate === 'insert') {
+ space.resource.abstractSpaceColl.cache.push(data);
+ } else {
+ space.resource.abstractSpaceColl.removeCache((i) => i.id != data.id);
+ }
+ break;
+ case '仓储空间':
+ space.standard.wareHousings = ArrayChanged(
+ space.standard.wareHousings,
+ operate,
+ data,
+ () => new WareHousing(data, space),
+ );
+ if (operate === 'insert') {
+ space.resource.wareHousingSpaceColl.cache.push(data);
+ } else {
+ space.resource.wareHousingSpaceColl.removeCache((i) => i.id != data.id);
+ }
+ break;
+ }
+}
+
+/** 数组元素操作 */
+function ArrayChanged(
+ arr: T[],
+ operate: string,
+ data: schema.XAbstractSpaceStandard,
+ create: () => T,
+): T[] {
+ if (operate === 'remove') {
+ return arr.filter((i) => i.id != data.id);
+ }
+ if (operate === 'insert') {
+ const index = arr.findIndex((i) => i.id === data.id);
+ if (index > -1) {
+ arr[index].setMetadata(data);
+ } else {
+ arr.push(create());
+ }
+ }
+ return arr;
+}
diff --git a/src/ts/core/abstractSpace/standard/warehousing.ts b/src/ts/core/abstractSpace/standard/warehousing.ts
new file mode 100644
index 0000000000000000000000000000000000000000..695fbcaafa7be346601c219a50469e70fe83f437
--- /dev/null
+++ b/src/ts/core/abstractSpace/standard/warehousing.ts
@@ -0,0 +1,354 @@
+import { model, schema } from '../../../base';
+import {
+ ISpace,
+ IStandardSpaceInfo,
+ StandardSpaceInfo,
+} from '@/ts/core/abstractSpace/abstractSpaceInfo';
+import { IAbstractSpace, ITarget } from '@/ts/core';
+import { DataResource } from '@/ts/core/thing/resource';
+import { spaceOperates, wareHousingOperates } from '@/ts/core/public';
+import {
+ GoodsShelvesSlot,
+ IGoodsShelvesSlot,
+} from '@/ts/core/abstractSpace/standard/goodsShelvesSlot';
+import { XGoodsShelves, XShelvesSlotRecord } from '@/ts/base/schema';
+interface Option {
+ value: string;
+ label: string;
+ children?: Option[];
+}
+//仓库
+export interface IWareHousing extends IStandardSpaceInfo {
+ /** 当前的用户 */
+ target: ITarget;
+ /** 资源集合 */
+ resource: DataResource;
+ abstractSpace: IAbstractSpace;
+ shelves: XGoodsShelves[];
+ /** 库位信息 */
+ shelvesSlots: IGoodsShelvesSlot[];
+ /** 新增货架信息 */
+ addGoodsShelves(data: schema.XGoodsShelves): Promise;
+ /** 更新货架信息 */
+ updateGoodsShelves(data: schema.XGoodsShelves): Promise;
+ /** 删除货架信息 */
+ deleteGoodsShelves(data: schema.XGoodsShelves): Promise;
+ /** 新增货架库位信息 */
+ addGoodsShelvesSlot(data: schema.XGoodsShelvesSlot[]): Promise;
+ loadThing(slotId: string, code?: string): Promise;
+ /** 上架 */
+ AddToInventory(slotId: string, thingId: string[]): Promise;
+ /** 下架 */
+ RemoveFromInventory(slotId: string, thingId: string[]): Promise;
+ ///** 加载货架库位信息 */
+ //loadGoodsShelvesSlots(reload?: boolean): Promise;
+ //记录
+ //record(formid, thingid)
+}
+
+export class WareHousing
+ extends StandardSpaceInfo
+ implements IWareHousing
+{
+ constructor(_metadata: schema.XWareHousingSpace, _space: IAbstractSpace) {
+ super(_metadata, _space.resource.wareHousingSpaceColl);
+ this.setEntity();
+ this.abstractSpace = _space;
+ this.target = _space.target;
+ this.resource = _space.resource;
+ }
+ abstractSpace: IAbstractSpace;
+ resource: DataResource;
+ target: ITarget;
+ shelves: XGoodsShelves[] = [];
+ shelvesSlots: IGoodsShelvesSlot[] = [];
+ private _slotsLoaded: boolean = false;
+ get selectOpt(): Option[] {
+ return this.shelves.map((shelf) => ({
+ value: shelf.id,
+ label: shelf.name,
+ children:
+ this.shelvesSlots
+ .filter((item: IGoodsShelvesSlot) => item.metadata?.goodsShelveId === shelf.id)
+ ?.map((slot) => ({
+ value: slot.id,
+ label: slot.name,
+ })) || [], // 如果没有库位则返回空数组
+ }));
+ }
+ async addGoodsShelves(data: schema.XGoodsShelves): Promise {
+ if (!this._metadata.goodsShelves) {
+ this._metadata.goodsShelves = [];
+ }
+ this._metadata.goodsShelves.push(data);
+ const result = await this.coll.replace({
+ ...this.metadata,
+ });
+ if (result) {
+ this.notify('replace', result);
+ return true;
+ }
+ return false;
+ }
+
+ async updateGoodsShelves(data: schema.XGoodsShelves): Promise {
+ const index = this._metadata.goodsShelves.findIndex((shelf) => shelf.id === data.id);
+ if (index !== -1) {
+ this._metadata.goodsShelves[index] = data;
+ }
+ const result = await this.coll.replace({
+ ...this.metadata,
+ });
+ if (result) {
+ this.notify('replace', result);
+ return true;
+ }
+ return false;
+ }
+
+ async deleteGoodsShelves(data: schema.XGoodsShelves): Promise {
+ this._metadata.goodsShelves = this._metadata.goodsShelves.filter(
+ (shelf) => shelf.id !== data.id,
+ );
+ const result = await this.coll.replace({
+ ...this.metadata,
+ });
+ if (result) {
+ await this.deleteSolts(data.id);
+ this.notify('replace', result);
+ return true;
+ }
+ return false;
+ }
+
+ async deleteSolts(shelfId: string) {
+ this.shelvesSlots
+ .filter((slot) => slot.metadata.goodsShelveId === shelfId)
+ .map((slot) => {
+ slot.delete();
+ });
+ }
+
+ async addGoodsShelvesSlot(data: schema.XGoodsShelvesSlot[]): Promise {
+ const extendedData = data.map((data: schema.XGoodsShelvesSlot) => ({
+ ...data,
+ typeName: '库位',
+ abstractSpaceId: this.abstractSpace.id,
+ wareHousingId: this.id,
+ }));
+ const result = await this.resource.goodsShelvesSlotColl.insertMany(extendedData);
+ if (result) {
+ await this.resource.goodsShelvesSlotColl.notity({
+ data: result,
+ operate: 'insert',
+ });
+ return true;
+ }
+ return false;
+ }
+
+ async AddToInventory(slotId: string, thingId: string[]): Promise {
+ const slot = this.shelvesSlots.find((slot) => slot.id === slotId);
+ if (slot) {
+ const result = await slot.AddToInventory(thingId);
+ if (result) {
+ console.log(await this.record(slot, 'add', thingId));
+ }
+ return result;
+ }
+ return false;
+ }
+
+ async RemoveFromInventory(slotId: string, thingId: string[]): Promise {
+ const slot = this.shelvesSlots.find((slot) => slot.id === slotId);
+ if (slot) {
+ const result = await slot.RemoveFromInventory(thingId);
+ if (result) {
+ console.log(await this.record(slot, 'remove', thingId));
+ // await this.record(slot, 'remove', thingId);
+ }
+ return result;
+ }
+ return false;
+ }
+
+ async loadThing(slotId: string, code?: string): Promise {
+ const slot = this.shelvesSlots.find((slot) => slot.id === slotId);
+ if (code) {
+ const res = await this.resource.thingColl.loadResult({
+ options: {
+ match: {
+ id: code,
+ isDeleted: false,
+ },
+ project: {
+ archives: 0,
+ },
+ },
+ });
+ return res.data ?? [];
+ }
+ const res = await this.resource.thingColl.loadResult({
+ options: {
+ match: {
+ id: { _in_: slot?.metadata?.inventory },
+ isDeleted: false,
+ },
+ project: {
+ archives: 0,
+ },
+ },
+ });
+ return res.data ?? [];
+ }
+
+ async record(
+ slot: IGoodsShelvesSlot,
+ operate: string,
+ thingId: string[],
+ ): Promise {
+ return await this.resource.shelvesSlotRecordColl.insertMany(
+ thingId.map(
+ (p) =>
+ ({
+ operate: operate,
+ wareHousingId: slot.metadata.wareHousingId,
+ //归属货架
+ goodsShelveId: slot.metadata.goodsShelveId,
+ //库位
+ goodsShelvesSlotId: slot.metadata.id,
+ //物资
+ goodsId: p,
+ } as XShelvesSlotRecord),
+ ),
+ );
+ }
+
+ get id(): string {
+ return this._metadata.id;
+ }
+
+ get superior(): ISpace {
+ return this.abstractSpace;
+ }
+
+ get cacheFlag(): string {
+ return 'wareHousings';
+ }
+
+ get isContainer(): boolean {
+ return false;
+ }
+
+ /** 库位总容量 */
+ get totalSlotsCapacity(): number {
+ return this.shelvesSlots.reduce((acc, slot) => acc + slot.metadata.capacity, 0);
+ }
+ /** 库位使用容量 */
+ get usedSlotsCapacity(): number {
+ return this.shelvesSlots.reduce(
+ (acc, slot) => acc + (slot.metadata?.inventory?.length ?? 0),
+ 0,
+ );
+ }
+ /** 库位利用率 */
+ get utilization(): number {
+ return this.totalSlotsCapacity > 0
+ ? Number(((this.usedSlotsCapacity / this.totalSlotsCapacity) * 100).toFixed(2))
+ : 0;
+ }
+
+ content(): ISpace[] {
+ const cnt = [...this.shelvesSlots];
+ return cnt.sort((a, b) => (a.metadata.updateTime < b.metadata.updateTime ? 1 : -1));
+ }
+
+ override operates(): model.OperateModel[] {
+ const operates: model.OperateModel[] = [];
+ operates.push(
+ wareHousingOperates.InBound,
+ wareHousingOperates.Outbound,
+ wareHousingOperates.Inventory,
+ );
+ operates.push(spaceOperates.Refesh, ...super.operates());
+ return operates;
+ }
+
+ async loadContent(reload: boolean = false): Promise {
+ this.shelves = this.metadata.goodsShelves;
+ await this.loadGoodsShelvesSlots(reload);
+ return true;
+ }
+
+ private async loadGoodsShelvesSlots(reload?: boolean): Promise {
+ if (!this._slotsLoaded || reload) {
+ const res = await this.resource.goodsShelvesSlotColl.loadResult({
+ options: {
+ match: {
+ abstractSpaceId: this.abstractSpace.id,
+ wareHousingId: this.id,
+ isDeleted: false,
+ },
+ project: { resource: 0 },
+ },
+ });
+ this._slotsLoaded = true;
+ if (res.success) {
+ this.shelvesSlots = (res.data || []).map(
+ (a) => new GoodsShelvesSlot(a, this.abstractSpace, this),
+ );
+ }
+ }
+ return this.shelvesSlots;
+ }
+
+ slotReceive(operate: string, data: schema.XGoodsShelvesSlot): boolean {
+ switch (operate) {
+ case 'insert':
+ {
+ this.resource.goodsShelvesSlotColl.cache.push(data);
+ this.shelvesSlots.push(new GoodsShelvesSlot(data, this.abstractSpace, this));
+ }
+ break;
+ case 'remove':
+ this.resource.goodsShelvesSlotColl.removeCache((i) => i.id !== data.id);
+ this.shelvesSlots = this.shelvesSlots.filter((a) => a.id !== data.id);
+ break;
+ case 'delete':
+ case 'replace':
+ var form = this.shelvesSlots.find((a) => a.id === data.id);
+ if (data && form) {
+ if (operate === 'delete') {
+ data = { ...data, isDeleted: true } as unknown as schema.XGoodsShelvesSlot;
+ }
+ form.setMetadata(data);
+ }
+ break;
+ default:
+ break;
+ }
+ return true;
+ }
+
+ override receive(operate: string, data: schema.XWareHousingSpace): boolean {
+ if (data.shareId === this.target.id) {
+ if (data.id === this.id) {
+ this.coll.removeCache((i) => i.id != data.id);
+ super.receive(operate, data);
+ this.coll.cache.push(this._metadata);
+ return true;
+ } else if ('wareHousingId' in data && data.wareHousingId === this.id) {
+ switch (data.typeName) {
+ case '库位':
+ this.slotReceive(operate, data as unknown as schema.XGoodsShelvesSlot);
+ break;
+ default:
+ break;
+ }
+ this.changCallback();
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/src/ts/core/index.ts b/src/ts/core/index.ts
index 03b5555c934a3961c7527b420473dd054fa48ca3..51c5cecc451ddfdaf0c1a01649377a81b90d00e8 100644
--- a/src/ts/core/index.ts
+++ b/src/ts/core/index.ts
@@ -50,3 +50,4 @@ export type { IPeriod } from './work/financial/period';
export type { IWorkTask, TaskTypeName } from './work/task';
export type { IOrder } from './mall/order/order';
export type { IAgent } from './target/team/agent';
+export type { IAbstractSpace } from './abstractSpace/abstractSpace';
diff --git a/src/ts/core/public/consts.ts b/src/ts/core/public/consts.ts
index 2d2e40a7196a553234f287c0f9c8a5512323f9cb..8a28260d64b00047387880adc1cfab372b3510a6 100644
--- a/src/ts/core/public/consts.ts
+++ b/src/ts/core/public/consts.ts
@@ -41,6 +41,7 @@ export const valueTypes = [
ValueType.Map,
ValueType.Object,
ValueType.TimeArray,
+ ValueType.Space,
];
/** 表单弹框支持的类型 */
export const formModalType = {
diff --git a/src/ts/core/public/enums.ts b/src/ts/core/public/enums.ts
index 78b612786e42ae87fb87a69517644b126c6ff53d..28cce8d9bf78b8cb1620d869e6990b1c42f7e0ec 100644
--- a/src/ts/core/public/enums.ts
+++ b/src/ts/core/public/enums.ts
@@ -107,6 +107,7 @@ export enum ValueType {
'Object' = '对象型',
'Currency' = '货币型',
'TimeArray' = '时间段型',
+ 'Space' = '空间型',
}
/** 规则触发时机 */
@@ -151,4 +152,4 @@ export enum MallTemplateMode {
sharing = '共享',
// 交易
trading = '交易',
-}
\ No newline at end of file
+}
diff --git a/src/ts/core/public/index.ts b/src/ts/core/public/index.ts
index 3cf8ea4021f722b43f7d08e3c2293315210fdfb0..073616f8807d05364ecb27544f1406b5eecfc46d 100644
--- a/src/ts/core/public/index.ts
+++ b/src/ts/core/public/index.ts
@@ -16,8 +16,9 @@ export {
entityOperates,
fileOperates,
memberOperates,
- newWarehouse,
personJoins,
+ spaceOperates,
+ wareHousingOperates,
targetOperates,
teamOperates,
} from './operates';
diff --git a/src/ts/core/public/operates.ts b/src/ts/core/public/operates.ts
index 10302867c47753af011edc3f6ff1fb6a51e949c3..0371ea08dcd8194065692765c565dc3328fb8987 100644
--- a/src/ts/core/public/operates.ts
+++ b/src/ts/core/public/operates.ts
@@ -462,20 +462,54 @@ export const applicationNew = {
],
};
-/** 新建仓库 */
-export const newWarehouse = {
+export const wareHousingOperates = {
+ InBound: {
+ sort: 4,
+ cmd: 'addToInventory',
+ label: '入库',
+ iconType: '',
+ },
+ Outbound: {
+ sort: 5,
+ cmd: 'removeFromInventory',
+ label: '出库',
+ iconType: '',
+ },
+ Inventory: {
+ sort: 6,
+ cmd: 'inventory',
+ label: '盘点',
+ iconType: '',
+ },
+};
+
+export const spaceOperates = {
+ Refesh: {
+ sort: 2,
+ cmd: 'reload',
+ label: '刷新空间',
+ iconType: 'refresh',
+ },
+ NewSpace: {
+ sort: 3,
+ cmd: 'newSpace',
+ label: '新建空间',
+ iconType: 'newDir',
+ },
+ NewWareHousingSpace: {
+ sort: 4,
+ cmd: 'newWareHousing',
+ label: '新建仓储空间',
+ iconType: 'newDir',
+ },
+};
+
+export const areaNew = {
sort: 0,
- cmd: 'newWarehouses',
- label: '仓库管理',
- iconType: 'newWarehouses',
- menus: [
- {
- sort: -1,
- cmd: 'newWarehouse',
- label: '新建仓库',
- iconType: 'newWarehouse',
- },
- ],
+ cmd: 'new',
+ label: '新建更多',
+ iconType: 'new',
+ menus: [spaceOperates.NewSpace, spaceOperates.NewWareHousingSpace],
};
/** 团队的操作 */
diff --git a/src/ts/core/target/base/target.ts b/src/ts/core/target/base/target.ts
index 023823d02d0aaa6205c4d2e271de795f08aa58ea..9cbc3da3212d49a84236d2e124ae219c09d79f8f 100644
--- a/src/ts/core/target/base/target.ts
+++ b/src/ts/core/target/base/target.ts
@@ -18,7 +18,7 @@ import { XObject } from '../../public/object';
import { WebSiteProvider } from '../../provider/website';
import { DomainProvider } from '../../provider/domain';
import { RelationType } from '@/ts/base/enum';
-
+import { AbstractSpace, IAbstractSpace } from '@/ts/core/abstractSpace/abstractSpace';
/** 用户抽象接口类 */
export interface ITarget extends ITeam, IFileInfo {
/** 会话 */
@@ -37,6 +37,8 @@ export interface ITarget extends ITeam, IFileInfo {
chats: ISession[];
/** 当前目录 */
directory: IDirectory;
+ /** 当前空间 */
+ abstractSpace: IAbstractSpace;
/** 数据核 */
storeId: string;
/** 接受的文件 */
@@ -94,6 +96,15 @@ export abstract class Target extends Team implements ITarget {
} as unknown as schema.XDirectory,
this,
);
+ this.abstractSpace = new AbstractSpace(
+ {
+ ..._metadata,
+ shareId: _metadata.id,
+ id: _metadata.id + '_',
+ typeName: '空间',
+ } as unknown as schema.XAbstractSpace,
+ this,
+ );
this.memberDirectory = new MemberDirectory(this);
this.session = new Session(this.id, this, _metadata);
this.recorder = new Recorder(this);
@@ -118,6 +129,7 @@ export abstract class Target extends Team implements ITarget {
space: IBelong;
session: ISession;
directory: IDirectory;
+ abstractSpace: IAbstractSpace;
resource: DataResource;
cache: schema.XCache;
identitys: IIdentity[] = [];
diff --git a/src/ts/core/target/person.ts b/src/ts/core/target/person.ts
index 2621d05e557a37e48532389349d4dc3577328762..9b820b6a89cc4aabd2cf3f0d7c42f668765293a5 100644
--- a/src/ts/core/target/person.ts
+++ b/src/ts/core/target/person.ts
@@ -334,6 +334,7 @@ export class Person extends Belong implements IPerson {
this._loadCommons(),
this.loadCompanys(reload),
this.directory.loadDirectoryResource(reload),
+ this.abstractSpace.loadSpaceResource(reload),
]);
setTimeout(async () => {
await Promise.all([
diff --git a/src/ts/core/target/team/company.ts b/src/ts/core/target/team/company.ts
index a44de3a677ada2f37550bcf0e0e2ef43e66f6451..491be3d2b473086f5a49bc30df1c1fb86532e9aa 100644
--- a/src/ts/core/target/team/company.ts
+++ b/src/ts/core/target/team/company.ts
@@ -305,6 +305,7 @@ export class Company extends Belong implements ICompany {
this.loadDepartments(reload),
]);
await this.directory.loadDirectoryResource(reload);
+ await this.abstractSpace.loadSpaceResource(reload);
setTimeout(async () => {
await Promise.all(
this.departments.map((department) => department.deepLoad(reload)),
diff --git a/src/ts/core/thing/resource.ts b/src/ts/core/thing/resource.ts
index 4720edf69887d8b5d0af66578c2aae2e61992d09..bbf3d8615c5aefac87de115b3a4d8803387213e8 100644
--- a/src/ts/core/thing/resource.ts
+++ b/src/ts/core/thing/resource.ts
@@ -33,6 +33,9 @@ import {
XAssignTaskTree, XAssignTaskTreeNode,
XOrder,
XAttribute,
+ XAbstractSpace,
+ XWareHousingSpace,
+ XGoodsShelvesSlot, XShelvesSlotRecord,
} from '../../base/schema';
import { BucketOpreates, ChatMessageType, Transfer } from '@/ts/base/model';
import { kernel, model } from '@/ts/base';
@@ -44,6 +47,7 @@ export class DataResource {
private target: XTarget;
private relations: string[];
private _proLoaded: boolean = false;
+ private _preSpaceLoaded: boolean = false;
constructor(target: XTarget, relations: string[], keys: string[]) {
this._keys = keys;
this.target = target;
@@ -93,6 +97,16 @@ export class DataResource {
this.assignTaskTreePublicColl =
this.genTargetColl('-assign-task-tree');
this.attributeColl = this.genTargetColl('standard-form-attribute');
+ this.abstractSpaceColl = this.genTargetColl('resource-space');
+ this.wareHousingSpaceColl = this.genTargetColl(
+ 'standard-space-warehousing',
+ );
+ this.goodsShelvesSlotColl = this.genTargetColl(
+ 'standard-space-shelves-slot',
+ );
+ this.shelvesSlotRecordColl = this.genTargetColl(
+ 'standard-inventory-record',
+ );
}
/** 表单集合 */
formColl: XCollection;
@@ -170,6 +184,13 @@ export class DataResource {
assignTaskTreePublicColl: XCollection;
/** 属性集合 */
attributeColl: XCollection;
+ /** 抽象空间集合 */
+ abstractSpaceColl: XCollection;
+ /** 仓储空间集合 */
+ wareHousingSpaceColl: XCollection;
+ /** 货架库位集合 */
+ goodsShelvesSlotColl: XCollection;
+ shelvesSlotRecordColl: XCollection;
/** 资源对应的用户信息 */
get targetMetadata() {
return this.target;
@@ -184,6 +205,15 @@ export class DataResource {
]);
}
}
+ async preSpaceLoad(reload: boolean = false): Promise {
+ if (!this._preSpaceLoaded || reload) {
+ this._preSpaceLoaded = true;
+ await Promise.all([
+ this.abstractSpaceColl.all(reload),
+ this.wareHousingSpaceColl.all(reload),
+ ]);
+ }
+ }
/** 生成集合 */
genColl(collName: string, relations?: string[]): XCollection {
return new XCollection(