981 lines
29 KiB
TypeScript
981 lines
29 KiB
TypeScript
import { ConnectTableEntity } from "./../entities/ConnectTableEntity";
|
|
import {
|
|
PollingEntity,
|
|
PollingTreeItemEntity,
|
|
} from "./../entities/PollingEntity";
|
|
import { store } from "quasar/wrappers";
|
|
import { ModeEntity, ModeTreeItemEntity } from "src/entities/ModeEntity";
|
|
import { WindowOpenNotifyEntity } from "src/entities/MultimediaWindowEntity";
|
|
import { PlanEntity, PlanTreeItemEntity } from "src/entities/PlanEntity";
|
|
import {
|
|
SignalSourceEntity,
|
|
SignalSourceTreeItemEntity,
|
|
} from "src/entities/SignalSourceEntity";
|
|
import { InjectionKey, reactive } from "vue";
|
|
import {
|
|
createStore,
|
|
Store as VuexStore,
|
|
useStore as vuexUseStore,
|
|
} from "vuex";
|
|
|
|
// import example from './module-example'
|
|
// import { ExampleStateInterface } from './module-example/state';
|
|
|
|
/*
|
|
* If not building with SSR mode, you can
|
|
* directly export the Store instantiation;
|
|
*
|
|
* The function below can be async too; either use
|
|
* async/await or return a Promise which resolves
|
|
* with the Store instance.
|
|
*/
|
|
|
|
export interface StateInterface {
|
|
// Define your own store structure, using submodules if needed
|
|
// example: ExampleStateInterface;
|
|
// Declared as unknown to avoid linting issue. Best to strongly type as per the line above.
|
|
initialized: boolean;
|
|
advanced_debug: boolean;
|
|
factory_mode: boolean;
|
|
signal_source_tree: SignalSourceTreeItemEntity[];
|
|
polling_tree: PollingTreeItemEntity[];
|
|
mode_tree: ModeTreeItemEntity[];
|
|
plan_tree: PlanTreeItemEntity[];
|
|
wall_row: number;
|
|
wall_col: number;
|
|
device_screen_width: number;
|
|
device_screen_height: number;
|
|
device_screen_refresh_rate: number;
|
|
device_screen_connect_state: boolean;
|
|
windows: WindowOpenNotifyEntity[];
|
|
windows_sort: string[];
|
|
device_ip_address: string;
|
|
power_on_plan: string;
|
|
fan_temp: number;
|
|
selected_window: string;
|
|
current_left_tab: string;
|
|
selected_signal_source: string;
|
|
selected_polling: string;
|
|
current_running_plan: string;
|
|
connect_list: ConnectTableEntity[];
|
|
|
|
modes: ModeEntity[];
|
|
plans: PlanEntity[];
|
|
pollings: PollingEntity[];
|
|
signal_sources: SignalSourceEntity[];
|
|
landspace: boolean;
|
|
device_attribute: number;
|
|
power_state: boolean;
|
|
product_name: string;
|
|
|
|
isLedPlayer: () => boolean;
|
|
isSpecialVideo: () => boolean;
|
|
}
|
|
|
|
// provide typings for `this.$store`
|
|
declare module "@vue/runtime-core" {
|
|
interface ComponentCustomProperties {
|
|
$store: VuexStore<StateInterface>;
|
|
}
|
|
}
|
|
|
|
class _TreeHelper {
|
|
public static findNode(node: any, key: string, value: string): any {
|
|
if (node && node.children && key && value != null && value != undefined) {
|
|
if (node[key] == value) {
|
|
return node;
|
|
}
|
|
|
|
for (let child of <any[]>node.children) {
|
|
if (child && child[key] == value) {
|
|
return child;
|
|
} else {
|
|
let _r = _TreeHelper.findNode(child, key, value);
|
|
if (_r) {
|
|
return _r;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static findNodeParent(node: any, key: string, value: string): any {
|
|
if (node && node.children && key && value != null && value != undefined) {
|
|
for (let child of <any[]>node.children) {
|
|
if (child && child[key] == value) {
|
|
return node;
|
|
} else {
|
|
let _r = _TreeHelper.findNodeParent(child, key, value);
|
|
if (_r) {
|
|
return _r;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static addTreeItem(
|
|
tree: any,
|
|
defaultItem: () => any,
|
|
createTreeItem: (
|
|
uuid: string,
|
|
parent: string,
|
|
name: string,
|
|
is_group: boolean
|
|
) => any,
|
|
playload?: any
|
|
) {
|
|
if (tree && playload) {
|
|
const parent = playload.parent ?? "";
|
|
const is_group = playload.is_group ?? false;
|
|
let item_data = playload.item_data ?? defaultItem();
|
|
let node = _TreeHelper.findNode(tree[0], "uuid", item_data.uuid);
|
|
if (node) {
|
|
return;
|
|
}
|
|
|
|
node = _TreeHelper.findNode(tree[0], "uuid", parent);
|
|
if (node) {
|
|
const node_item = createTreeItem(
|
|
item_data.uuid,
|
|
parent,
|
|
item_data.name,
|
|
is_group
|
|
);
|
|
node_item.item_data = item_data;
|
|
(<any[]>node.children).push(node_item);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static setTreeItem(
|
|
tree: any,
|
|
defaultItem: () => any,
|
|
copy: (left: any, right: any) => void,
|
|
playload?: any
|
|
) {
|
|
if (tree && playload) {
|
|
let item_data = playload.item_data ?? defaultItem();
|
|
let node = _TreeHelper.findNode(tree[0], "uuid", item_data.uuid);
|
|
if (node) {
|
|
copy(node.item_data, item_data);
|
|
node.name = item_data.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static deleteTreeItem(tree: any, playload?: any) {
|
|
if (tree && playload && playload.uuid) {
|
|
let parent = _TreeHelper.findNodeParent(tree[0], "uuid", playload.uuid);
|
|
if (parent) {
|
|
let node_index = (<any[]>parent.children).findIndex(
|
|
(item) => item && item.uuid == playload.uuid
|
|
);
|
|
if (node_index != -1) {
|
|
(<any[]>parent.children).splice(node_index, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static findGroupsByParent(parent: string, array: any[]) {
|
|
return array.filter((item) => {
|
|
return item && item.parent_uuid == parent;
|
|
});
|
|
}
|
|
|
|
public static findItemsByParent(parent: string, array: any[]) {
|
|
return array.filter((item) => {
|
|
return item && item.group_uuid == parent;
|
|
});
|
|
}
|
|
|
|
public static buildGroup(
|
|
parent: any,
|
|
createTreeItem: (
|
|
uuid?: string,
|
|
parent?: string,
|
|
name?: string,
|
|
is_group?: boolean,
|
|
item_data?: any,
|
|
children?: any[]
|
|
) => any,
|
|
group_array: any[],
|
|
item_array: any[]
|
|
) {
|
|
if (parent) {
|
|
for (let item of _TreeHelper.findGroupsByParent(
|
|
parent.uuid,
|
|
group_array
|
|
)) {
|
|
const node_item = createTreeItem(
|
|
item.uuid,
|
|
parent.uuid,
|
|
item.name,
|
|
true
|
|
);
|
|
node_item.item_data = item;
|
|
parent.children.push(node_item);
|
|
_TreeHelper.buildGroup(
|
|
node_item,
|
|
createTreeItem,
|
|
group_array,
|
|
item_array
|
|
);
|
|
}
|
|
|
|
for (let item of _TreeHelper.findItemsByParent(parent.uuid, item_array)) {
|
|
const node_item = createTreeItem(
|
|
item.uuid,
|
|
parent.uuid,
|
|
item.name,
|
|
false,
|
|
item
|
|
);
|
|
parent.children.push(node_item);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static buildTree(
|
|
tree: any,
|
|
group_name: string,
|
|
items_name: string,
|
|
root_text: string,
|
|
createTreeItem: (
|
|
uuid?: string,
|
|
parent?: string,
|
|
name?: string,
|
|
is_group?: boolean,
|
|
item_data?: any,
|
|
children?: any[]
|
|
) => any,
|
|
playload?: any
|
|
) {
|
|
if (
|
|
tree &&
|
|
playload &&
|
|
playload.response &&
|
|
playload.options &&
|
|
playload.options.$t
|
|
) {
|
|
const $t = playload.options.$t;
|
|
const groups = playload.response[group_name] ?? [];
|
|
const items = playload.response[items_name] ?? [];
|
|
|
|
const root = createTreeItem("", "", $t.t(root_text ?? "root"), true, {
|
|
uuid: "",
|
|
name: "",
|
|
parent_uuid: "",
|
|
group_uuid: "",
|
|
});
|
|
|
|
tree.splice(0, tree.length);
|
|
tree.push(root);
|
|
|
|
_TreeHelper.buildGroup(root, createTreeItem, groups, items);
|
|
} else {
|
|
console.error(playload);
|
|
}
|
|
}
|
|
}
|
|
|
|
// provide typings for `useStore` helper
|
|
export const storeKey: InjectionKey<VuexStore<StateInterface>> =
|
|
Symbol("vuex-key");
|
|
|
|
import window_color_list from "./window_color_list.js";
|
|
import { EProductNames } from "src/entities/ProductNames";
|
|
export const NullSignalSource =
|
|
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
|
|
|
|
export default store(function (/* { ssrContext } */) {
|
|
const Store: VuexStore<StateInterface> = createStore<StateInterface>({
|
|
modules: {
|
|
// example
|
|
},
|
|
state: {
|
|
// state
|
|
initialized: false,
|
|
advanced_debug: false,
|
|
factory_mode: false,
|
|
signal_source_tree: [],
|
|
polling_tree: [],
|
|
mode_tree: [],
|
|
plan_tree: [],
|
|
wall_col: 1,
|
|
wall_row: 1,
|
|
device_screen_width: 0,
|
|
device_screen_height: 0,
|
|
device_screen_refresh_rate: 0,
|
|
device_screen_connect_state: true,
|
|
windows: [],
|
|
windows_sort: [],
|
|
device_ip_address: "localhost",
|
|
power_on_plan: "",
|
|
fan_temp: 0,
|
|
selected_window: "",
|
|
current_left_tab: "signal_source",
|
|
selected_signal_source: NullSignalSource,
|
|
selected_polling: NullSignalSource,
|
|
current_running_plan: "",
|
|
connect_list: [],
|
|
modes: [],
|
|
plans: [],
|
|
pollings: [],
|
|
signal_sources: [],
|
|
landspace: window.innerWidth > window.innerHeight,
|
|
device_attribute: 0,
|
|
power_state: false,
|
|
product_name: EProductNames.LED_PLAYER,
|
|
|
|
isLedPlayer: () => {
|
|
return (
|
|
Store.state.product_name == EProductNames.LED_PLAYER ||
|
|
Store.state.product_name == EProductNames.OLD_LED_PLAYER
|
|
);
|
|
},
|
|
isSpecialVideo: () => {
|
|
return Store.state.product_name == EProductNames.SPECIAL_VIDEO;
|
|
},
|
|
},
|
|
|
|
mutations: {
|
|
setInitialized(state: StateInterface, playload?: any) {
|
|
state.initialized = true;
|
|
},
|
|
updateLandspace(state: StateInterface, playload?: any) {
|
|
if (typeof playload == "boolean") {
|
|
state.landspace = playload;
|
|
}
|
|
},
|
|
setPowerState(state: StateInterface, playload: boolean) {
|
|
state.power_state = playload;
|
|
},
|
|
setProductName(state: StateInterface, playload?: any) {
|
|
if (
|
|
playload == EProductNames.LED_PLAYER ||
|
|
playload == EProductNames.SPECIAL_VIDEO ||
|
|
playload == EProductNames.OLD_LED_PLAYER
|
|
) {
|
|
state.product_name = playload;
|
|
}
|
|
},
|
|
setDeviceAttribute(state: StateInterface, playload?: any) {
|
|
const num = parseInt(playload);
|
|
if (!isNaN(num) && num >= 0) {
|
|
state.device_attribute = num;
|
|
}
|
|
},
|
|
setAvancedDebug(state: StateInterface, playload?: any) {
|
|
if (playload || playload == "true") {
|
|
console.log("debug", playload);
|
|
state.advanced_debug = playload;
|
|
}
|
|
state.advanced_debug = playload;
|
|
},
|
|
setFactoryMode(state: StateInterface, playload?: any) {
|
|
if (playload || playload == "true") {
|
|
console.log("factory", playload);
|
|
}
|
|
state.factory_mode = playload;
|
|
},
|
|
setArrayValue(state: StateInterface, playload?: any) {
|
|
if (Array.isArray(playload.value)) {
|
|
const arr: Array<any> = (<any>state)[playload.name];
|
|
if (arr) {
|
|
arr.splice(0, arr.length);
|
|
for (const item of playload.value) {
|
|
if (item) {
|
|
arr.push(item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
setWindowPropertys(state: StateInterface, playload?: any[]) {
|
|
if (playload && Array.isArray(playload)) {
|
|
for (let item of playload) {
|
|
const window = item.window;
|
|
const property_name = item.property_name;
|
|
const value = item.value;
|
|
try {
|
|
if (window && property_name) {
|
|
window[property_name] = value;
|
|
}
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
setWindowProperty(state: StateInterface, playload?: any) {
|
|
const window = playload.window;
|
|
const property_name = playload.property_name;
|
|
const value = playload.value;
|
|
if (window && property_name) {
|
|
window[property_name] = value;
|
|
}
|
|
},
|
|
setWindowClientProperty(state: StateInterface, playload?: any) {
|
|
const window = playload.window;
|
|
const property_name = playload.property_name;
|
|
const value = playload.value;
|
|
if (window && property_name) {
|
|
window.client_propertys[property_name] = value;
|
|
}
|
|
},
|
|
setWindows(state: StateInterface, playload?: WindowOpenNotifyEntity[]) {
|
|
if (playload) {
|
|
state.windows = playload;
|
|
state.windows_sort = [];
|
|
for (const item of state.windows) {
|
|
state.windows_sort.push(item.uuid);
|
|
}
|
|
for (const window of state.windows) {
|
|
if (window) {
|
|
try {
|
|
window.client_color = window_color_list.splice(
|
|
Math.round(Math.random() * window_color_list.length),
|
|
1
|
|
)[0];
|
|
} catch {}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
clearWindows(state: StateInterface, playload?: any) {
|
|
state.windows = [];
|
|
state.windows_sort = [];
|
|
},
|
|
pushWindow(state: StateInterface, playload?: WindowOpenNotifyEntity) {
|
|
if (playload) {
|
|
if (
|
|
state.windows.find((e) => e && e.window_id == playload.window_id)
|
|
) {
|
|
return;
|
|
}
|
|
try {
|
|
playload.client_color = window_color_list.splice(
|
|
Math.round(Math.random() * window_color_list.length - 1),
|
|
1
|
|
)[0];
|
|
} catch {}
|
|
state.windows.push(playload);
|
|
state.windows_sort.push(playload.uuid);
|
|
}
|
|
},
|
|
topWindow(state: StateInterface, playload?: number) {
|
|
const window = state.windows.find(
|
|
(element) => element && element.window_id == playload
|
|
);
|
|
if (window) {
|
|
if (window) {
|
|
const index = state.windows_sort.findIndex(
|
|
(element) => element && element == window.uuid
|
|
);
|
|
if (index >= 0) {
|
|
state.windows_sort.splice(index, 1);
|
|
state.windows_sort.push(window.uuid);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
lowerWindow(state: StateInterface, playload?: number) {
|
|
const window = state.windows.find(
|
|
(element) => element && element.window_id == playload
|
|
);
|
|
if (window) {
|
|
const index = state.windows_sort.findIndex(
|
|
(element) => element && element == window.uuid
|
|
);
|
|
if (index >= 0) {
|
|
state.windows_sort.splice(index, 1);
|
|
state.windows_sort.unshift(window.uuid);
|
|
}
|
|
}
|
|
},
|
|
removeWindow(state: StateInterface, playload?: any) {
|
|
const window_id = playload.window_id;
|
|
if (window_id) {
|
|
let index = state.windows.findIndex(
|
|
(item) => item && item.window_id == window_id
|
|
);
|
|
if (index >= 0) {
|
|
const window = state.windows[index];
|
|
window_color_list.push(window.client_color);
|
|
state.windows.splice(index, 1);
|
|
|
|
let __index = state.windows_sort.findIndex(
|
|
(element) => element && element == window.uuid
|
|
);
|
|
if (__index >= 0) {
|
|
state.windows_sort.splice(__index, 1);
|
|
}
|
|
}
|
|
} else {
|
|
console.log("window_id???");
|
|
}
|
|
},
|
|
cleanWindows(state: StateInterface, playload?: any) {
|
|
state.windows.splice(0, state.windows.length);
|
|
},
|
|
editWindow(state: StateInterface, playload?: any) {
|
|
const uuid = playload.uuid;
|
|
const new_window = playload.new_window as WindowOpenNotifyEntity;
|
|
if (uuid && new_window) {
|
|
let index = state.windows.findIndex(
|
|
(item) => item && item.uuid == uuid
|
|
);
|
|
if (index >= 0) {
|
|
state.windows[index] = new_window;
|
|
}
|
|
}
|
|
},
|
|
setWallCol(state: StateInterface, playload?: any) {
|
|
const num = parseInt(playload);
|
|
if (num != NaN && num > 0) {
|
|
state.wall_col = num;
|
|
}
|
|
},
|
|
setWallRow(state: StateInterface, playload?: any) {
|
|
const num = parseInt(playload);
|
|
if (num != NaN && num > 0) {
|
|
state.wall_row = num;
|
|
}
|
|
},
|
|
setDeviceScreenWidth(state: StateInterface, playload?: any) {
|
|
const num = parseInt(playload);
|
|
if (num != NaN && num > 0) {
|
|
state.device_screen_width = num;
|
|
}
|
|
},
|
|
setDeviceScreenHeight(state: StateInterface, playload?: any) {
|
|
const num = parseInt(playload);
|
|
if (num != NaN && num > 0) {
|
|
state.device_screen_height = num;
|
|
}
|
|
},
|
|
setDeviceScreenRefreshRate(state: StateInterface, playload?: any) {
|
|
const num = parseInt(playload);
|
|
if (num != NaN && num > 0) {
|
|
state.device_screen_refresh_rate = num;
|
|
}
|
|
},
|
|
setDeviceScreenConnectState(state: StateInterface, playload?: any) {
|
|
try {
|
|
state.device_screen_connect_state = JSON.parse(playload);
|
|
} catch {}
|
|
},
|
|
// signal source
|
|
setSignalSourceTree(
|
|
state: StateInterface,
|
|
playload?: SignalSourceTreeItemEntity[]
|
|
) {
|
|
if (playload) {
|
|
state.signal_source_tree = playload;
|
|
}
|
|
},
|
|
clearSignalSourceTree(state: StateInterface, playload?: any) {
|
|
state.signal_source_tree = [];
|
|
},
|
|
pushSignalSourceTreeItem(
|
|
state: StateInterface,
|
|
playload?: SignalSourceTreeItemEntity
|
|
) {
|
|
if (playload) {
|
|
state.signal_source_tree.push(playload);
|
|
}
|
|
},
|
|
addSignalSourceTreeItem(state: StateInterface, playload?: any) {
|
|
if (playload) {
|
|
const parent = playload.parent ?? "";
|
|
const is_group = playload.is_group ?? false;
|
|
let item_data = playload.item_data ?? new SignalSourceEntity();
|
|
if (item_data && item_data.local_file_flag) {
|
|
return;
|
|
}
|
|
let node = _TreeHelper.findNode(
|
|
state.signal_source_tree[0],
|
|
"uuid",
|
|
item_data.uuid
|
|
);
|
|
if (node) {
|
|
return;
|
|
}
|
|
|
|
node = _TreeHelper.findNode(
|
|
state.signal_source_tree[0],
|
|
"uuid",
|
|
parent
|
|
);
|
|
if (node) {
|
|
const node_item = new SignalSourceTreeItemEntity(
|
|
item_data.uuid,
|
|
parent,
|
|
item_data.name,
|
|
is_group
|
|
);
|
|
node_item.item_data = item_data;
|
|
(<any[]>node.children).push(node_item);
|
|
}
|
|
}
|
|
},
|
|
setSignalSourceTreeItem(state: StateInterface, playload?: any) {
|
|
if (playload) {
|
|
let item_data = playload.item_data ?? new SignalSourceEntity();
|
|
let node = _TreeHelper.findNode(
|
|
state.signal_source_tree[0],
|
|
"uuid",
|
|
item_data.uuid
|
|
);
|
|
if (node) {
|
|
SignalSourceEntity.copy(node.item_data, item_data);
|
|
node.name = item_data.name;
|
|
}
|
|
}
|
|
},
|
|
deleteSignalSourceTreeItem(state: StateInterface, playload?: any) {
|
|
if (playload && playload.uuid) {
|
|
let parent = _TreeHelper.findNodeParent(
|
|
state.signal_source_tree[0],
|
|
"uuid",
|
|
playload.uuid
|
|
);
|
|
if (parent) {
|
|
let node_index = (<any[]>parent.children).findIndex(
|
|
(item) => item && item.uuid == playload.uuid
|
|
);
|
|
if (node_index != -1) {
|
|
(<any[]>parent.children).splice(node_index, 1);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
buildSignalSourceTree(state: StateInterface, playload?: any) {
|
|
const buildGroup = (
|
|
parent: SignalSourceTreeItemEntity,
|
|
group_array: any[],
|
|
item_array: any[]
|
|
) => {
|
|
if (parent) {
|
|
for (let item of findGroupsByParent(parent.uuid, group_array)) {
|
|
const node_item = new SignalSourceTreeItemEntity(
|
|
item.uuid,
|
|
parent.uuid,
|
|
item.name,
|
|
true
|
|
);
|
|
node_item.item_data = item;
|
|
parent.children.push(node_item);
|
|
buildGroup(node_item, group_array, item_array);
|
|
}
|
|
|
|
for (let item of findItemsByParent(parent.uuid, item_array)) {
|
|
const node_item = new SignalSourceTreeItemEntity(
|
|
item.uuid,
|
|
parent.uuid,
|
|
item.name,
|
|
false,
|
|
item
|
|
);
|
|
if (
|
|
node_item &&
|
|
node_item.item_data &&
|
|
!node_item.item_data.local_file_flag
|
|
) {
|
|
parent.children.push(node_item);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
const findGroupsByParent = (parent: string, array: any[]) => {
|
|
return array.filter((item) => {
|
|
return item && item.parent_uuid == parent;
|
|
});
|
|
};
|
|
|
|
const findItemsByParent = (parent: string, array: any[]) => {
|
|
return array.filter((item) => {
|
|
return item && item.group_uuid == parent;
|
|
});
|
|
};
|
|
|
|
if (
|
|
playload &&
|
|
playload.response &&
|
|
playload.options &&
|
|
playload.options.$t
|
|
) {
|
|
const $t = playload.options.$t;
|
|
const signal_source_groups =
|
|
playload.response.signal_source_groups ?? [];
|
|
const signal_sources = playload.response.signal_sources ?? [];
|
|
|
|
const root = new SignalSourceTreeItemEntity(
|
|
"",
|
|
"",
|
|
$t.t("signal source"),
|
|
true,
|
|
new SignalSourceEntity()
|
|
);
|
|
|
|
state.signal_source_tree.splice(0, state.signal_source_tree.length);
|
|
state.signal_source_tree.push(root);
|
|
|
|
buildGroup(root, signal_source_groups, signal_sources);
|
|
} else {
|
|
console.error(playload);
|
|
}
|
|
},
|
|
//mode tree
|
|
setModeTree(state: StateInterface, playload?: ModeTreeItemEntity[]) {
|
|
if (playload) {
|
|
state.mode_tree = playload;
|
|
}
|
|
},
|
|
clearModeTree(state: StateInterface, playload?: any) {
|
|
state.mode_tree = [];
|
|
},
|
|
pushModeTreeItem(state: StateInterface, playload?: ModeTreeItemEntity) {
|
|
if (playload) {
|
|
state.mode_tree.push(playload);
|
|
}
|
|
},
|
|
addModeTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.addTreeItem(
|
|
state.mode_tree,
|
|
() => new ModeEntity(),
|
|
(uuid: string, parent: string, name: string, is_group: boolean) =>
|
|
new ModeTreeItemEntity(uuid, parent, name, is_group),
|
|
playload
|
|
);
|
|
},
|
|
setModeTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.setTreeItem(
|
|
state.mode_tree,
|
|
() => new ModeEntity(),
|
|
(left: any, right: any) => ModeEntity.copy(left, right),
|
|
playload
|
|
);
|
|
},
|
|
deleteModeTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.deleteTreeItem(state.mode_tree, playload);
|
|
},
|
|
buildModeTree(state: StateInterface, playload?: any) {
|
|
_TreeHelper.buildTree(
|
|
state.mode_tree,
|
|
"mode_groups",
|
|
"modes",
|
|
"mode",
|
|
(
|
|
uuid?: string,
|
|
parent?: string,
|
|
name?: string,
|
|
is_group?: boolean,
|
|
item_data?: any,
|
|
children?: ModeTreeItemEntity[]
|
|
) =>
|
|
new ModeTreeItemEntity(
|
|
uuid,
|
|
parent,
|
|
name,
|
|
is_group,
|
|
item_data,
|
|
children
|
|
),
|
|
playload
|
|
);
|
|
},
|
|
// plan tree
|
|
setPlanTree(state: StateInterface, playload?: PlanTreeItemEntity[]) {
|
|
if (playload) {
|
|
state.plan_tree = playload;
|
|
}
|
|
},
|
|
clearPlanTree(state: StateInterface, playload?: any) {
|
|
state.plan_tree = [];
|
|
},
|
|
pushPlanTreeItem(state: StateInterface, playload?: PlanTreeItemEntity) {
|
|
if (playload) {
|
|
state.plan_tree.push(playload);
|
|
}
|
|
},
|
|
addPlanTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.addTreeItem(
|
|
state.plan_tree,
|
|
() => new PlanEntity(),
|
|
(uuid: string, parent: string, name: string, is_group: boolean) =>
|
|
new PlanTreeItemEntity(uuid, parent, name, is_group),
|
|
playload
|
|
);
|
|
},
|
|
setPlanTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.setTreeItem(
|
|
state.plan_tree,
|
|
() => new PlanEntity(),
|
|
(left: any, right: any) => PlanEntity.copy(left, right),
|
|
playload
|
|
);
|
|
},
|
|
deletePlanTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.deleteTreeItem(state.plan_tree, playload);
|
|
},
|
|
buildPlanTree(state: StateInterface, playload?: any) {
|
|
_TreeHelper.buildTree(
|
|
state.plan_tree,
|
|
"plan_groups",
|
|
"plans",
|
|
"plan",
|
|
(
|
|
uuid?: string,
|
|
parent?: string,
|
|
name?: string,
|
|
is_group?: boolean,
|
|
item_data?: any,
|
|
children?: PlanTreeItemEntity[]
|
|
) =>
|
|
new PlanTreeItemEntity(
|
|
uuid,
|
|
parent,
|
|
name,
|
|
is_group,
|
|
item_data,
|
|
children
|
|
),
|
|
playload
|
|
);
|
|
},
|
|
// polling tree
|
|
setPollingTree(
|
|
state: StateInterface,
|
|
playload?: PollingTreeItemEntity[]
|
|
) {
|
|
if (playload) {
|
|
state.polling_tree = playload;
|
|
}
|
|
},
|
|
clearPollingTree(state: StateInterface, playload?: any) {
|
|
state.polling_tree = [];
|
|
},
|
|
pushPollingTreeItem(
|
|
state: StateInterface,
|
|
playload?: PollingTreeItemEntity
|
|
) {
|
|
if (playload) {
|
|
state.polling_tree.push(playload);
|
|
}
|
|
},
|
|
addPollingTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.addTreeItem(
|
|
state.polling_tree,
|
|
() => new PollingEntity(),
|
|
(uuid: string, parent: string, name: string, is_group: boolean) =>
|
|
new PollingTreeItemEntity(uuid, parent, name, is_group),
|
|
playload
|
|
);
|
|
},
|
|
setPollingTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.setTreeItem(
|
|
state.polling_tree,
|
|
() => new PollingEntity(),
|
|
(left: any, right: any) => PollingEntity.copy(left, right),
|
|
playload
|
|
);
|
|
},
|
|
deletePollingTreeItem(state: StateInterface, playload?: any) {
|
|
_TreeHelper.deleteTreeItem(state.polling_tree, playload);
|
|
},
|
|
buildPollingTree(state: StateInterface, playload?: any) {
|
|
_TreeHelper.buildTree(
|
|
state.polling_tree,
|
|
"polling_groups",
|
|
"pollings",
|
|
"signal polling",
|
|
(
|
|
uuid?: string,
|
|
parent?: string,
|
|
name?: string,
|
|
is_group?: boolean,
|
|
item_data?: any,
|
|
children?: PollingTreeItemEntity[]
|
|
) =>
|
|
new PollingTreeItemEntity(
|
|
uuid,
|
|
parent,
|
|
name,
|
|
is_group,
|
|
item_data,
|
|
children
|
|
),
|
|
playload
|
|
);
|
|
},
|
|
// polling tree end
|
|
setDeviceIpAddress(state: StateInterface, playload?: any) {
|
|
if (playload) state.device_ip_address = playload;
|
|
},
|
|
setPowerOnPlan(state: StateInterface, playload?: any) {
|
|
if (playload != null && playload != undefined)
|
|
state.power_on_plan = playload;
|
|
},
|
|
setFanTemp(state: StateInterface, playload?: any) {
|
|
const f = parseFloat(playload);
|
|
if (!isNaN(f)) {
|
|
state.fan_temp = f;
|
|
}
|
|
},
|
|
setSelectedWindow(state: StateInterface, playload?: any) {
|
|
state.selected_window = playload;
|
|
},
|
|
setCurrentLeftTab(state: StateInterface, playload?: any) {
|
|
if (typeof playload == "string") {
|
|
state.current_left_tab = playload;
|
|
}
|
|
},
|
|
setSelectedSignalSource(state: StateInterface, playload?: any) {
|
|
if (state.selected_signal_source == playload) {
|
|
state.selected_signal_source = NullSignalSource;
|
|
} else {
|
|
state.selected_signal_source = playload;
|
|
}
|
|
},
|
|
setSelectedPolling(state: StateInterface, playload?: any) {
|
|
if (state.selected_polling == playload) {
|
|
state.selected_polling = NullSignalSource;
|
|
} else {
|
|
state.selected_polling = playload;
|
|
}
|
|
},
|
|
setCurrentRunningPlan(state: StateInterface, playload?: any) {
|
|
state.current_running_plan = playload;
|
|
},
|
|
setConnects(state: StateInterface, playload?: any) {
|
|
state.connect_list = playload;
|
|
},
|
|
addConnectItem(state: StateInterface, playload?: any) {
|
|
state.connect_list.push(playload);
|
|
},
|
|
cleanConnectItem(state: StateInterface, playload?: any) {
|
|
const index = state.connect_list.findIndex(
|
|
(element) => element && element.uuid == playload
|
|
);
|
|
if (index != -1) {
|
|
state.connect_list.slice(index, 1);
|
|
}
|
|
},
|
|
},
|
|
|
|
// enable strict mode (adds overhead!)
|
|
// for dev mode and --debug builds only
|
|
strict: !!process.env.DEBUGGING,
|
|
});
|
|
|
|
return Store;
|
|
});
|
|
|
|
export function useStore() {
|
|
return vuexUseStore(storeKey);
|
|
}
|