#

luxiaotao1123

2024-10-16 b20fdb26e9d1d091fd7864de1edcc639e9da01b8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import request from '@/utils/request';
import * as Tool from './tool';
import { DEVICE_TYPE } from './constants';
 
let notify;
let mapContainer;
 
export function setNotify(param) {
    notify = param;
}
 
export function setMapContainer(param) {
    mapContainer = param;
}
 
export const fetchMapData = async (zoneId) => {
    Tool.clearMapData();
    await request.post('/map/data/fetch', {
        zoneId: zoneId
    }, {
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
    }).then((res) => {
        const { code, msg, data: { common, point } } = res.data;
        if (code === 200) {
            const mapItemList = [...eval(common), ...eval(point)];
            mapItemList.forEach(item => {
                if (item.type !== DEVICE_TYPE.AGV) {
                    const sprite = Tool.generateSprite(item.type);
                    if (sprite) {
                        Tool.initSprite(sprite, item.type);
                        // data
                        sprite.data.uuid = item.uuid;
                        sprite.data.no = item.no;
 
                        // dynamical data
                        Object.assign(sprite.data, item.property);
 
                        // graph
                        setTimeout(() => {
                            sprite.position.set(item.positionX, item.positionY);
                            sprite.scale.set(item.scaleX, item.scaleY);
                            sprite.rotation = Tool.rotationParseNum(item.rotation);
 
                            // support
                            switch (item.type) {
                                case DEVICE_TYPE.POINT:
                                    sprite.tint = 0xCACDCF;
                                    sprite.scale.set(0.65, 0.65);
                                    break
                                default:
                                    break
                            }
                        }, 50);
 
                        mapContainer.addChild(sprite);
                    }
                }
            })
        } else {
            notify.error(msg);
        }
    }).catch((error) => {
        notify.error(error.message);
        console.error(error.message);
    })
}
 
export const saveMapData = async (zone) => {
    if (!mapContainer) {
        return;
    }
 
    const sprites = [];
    mapContainer.children.forEach(child => {
        if (child.data?.uuid) {
            const { type, uuid, no, ...property } = child.data;
            if (type !== DEVICE_TYPE.AGV && type !== DEVICE_TYPE.POINT) {
                sprites.push({
                    // graph
                    positionX: child.position.x,
                    positionY: child.position.y,
                    scaleX: child.scale.x,
                    scaleY: child.scale.y,
                    rotation: Tool.rotationToNum(child.rotation),
                    // data
                    type: type,
                    uuid: uuid,
                    no: no,
                    property: property,
                })
            }
        }
    })
 
    await request.post('/map/data/save', {
        zoneId: zone,
        itemList: sprites
    }).then(res => {
        const { code, msg, data } = res.data;
        if (code === 200) {
            notify.success(msg);
        } else {
            notify.error(msg);
        }
    }).catch((error) => {
        notify.error(error.message);
        console.error(error.message);
    })
}
 
 
export const getLocGroup = async (row, bay, callback) => {
    await request.post('/map/shelf/group', {
        row: row,
        bay: bay
    }, {
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
    }).then((res) => {
        const { code, msg, data } = res.data;
        if (code === 200) {
            callback(data)
        } else {
            notify.error(msg);
        }
    }).catch((error) => {
        notify.error(error.message);
        console.error(error.message);
    })
}