import './cellsysKeyword.js';
import {
    Query,
    QueryTask,
    QueryType,
    EditTask,
    EditType,
    Operator,
    CellsysType,
    QueryMG,
    SubmitType,
} from './cellsysUtil.js';
import * as CellsysPush from './cellsysPush.js';

import CellsysUser from './cellsysUser.js';
import CellsysApp from './cellsysApp.js';
import CellsysAppModelType from './CellsysAppModelType.js';
import CellsysAppModel from './cellsysAppModel.js';
import CellsysGroup from './cellsysGroup.js';
import CellsysMember from './cellsysMember.js';
import CellsysMemberType from './cellsysMemberType.js';
import CellsysMark from './cellsysMark.js';
import CellsysMarkType from './cellsysMarkType.js';
import CellsysPolygon from './cellsysPolygon.js';
import CellsysPolygonType from './cellsysPolygonType.js';
import CellsysLine from './cellsysLine.js';
import CellsysLineType from './cellsysLineType.js';
import CellsysLayer from './cellsysLayer.js';
import CellsysLayerGroup from './cellsysLayerGroup.js';
import CellsysEvent from './cellsysEvent.js';
import CellsysEventType from './cellsysEventType.js';
import CellsysEquipment from './cellsysEquipment.js';
import CellsysEquipmentUser from './cellsysEquipmentUser.js';
import CellsysEquipmentType from './cellsysEquipmentType.js';
import CellsysFenceEvent from './cellsysFenceEvent.js';
import CellsysTask from './cellsysTask.js';
import CellsysTaskGeom from './cellsysTaskGeom.js';
import CellsysTaskType from './cellsysTaskType.js';
import CellsysOfflinePolygon from './cellsysOfflinePolygon.js';
import CellsysOfflinePolygonType from './cellsysOfflinePolygonType';
import CellsysEquipmentMonitor from './cellsysEquipmentMonitor';
import CellsysTag from './cellsysTag';

/** */

class CellsysOrg {
    constructor(params) {
        this.cellsysType = CellsysType.Org;
        if (!params) {
            params = {};
        }
        this.id = params.id ? params.id : null;
        this.name = params.name ? params.name : null;
        this.logo = params.logo ? params.logo : null;
        this.status = params.status || params.status === 0 ? params.status : null;
        this.abbreviation = params.abbreviation ? params.abbreviation : null;
        this.create_by = params.create_by ? params.create_by : null;
        this.description = params.description ? params.description : null;
        this.address = params.address ? params.address : null;
        this.contact = params.contact ? params.contact : null;
        this.phone = params.phone ? params.phone : null;
        this.email = params.email ? params.email : null;
        this.options = params.options ? params.options : {};
        this.keyword = params.keyword
            ? Object.assign(window['CellsysKeyword'], params.keyword)
            : window['CellsysKeyword'];
        this.uuid = params.uuid ? params.uuid : null;
        this.industryId = params.industry_id ? params.industry_id : [];
        this.actionType = {
            //???为什么org会有这个属性
            1: { id: 1, name: '进入围栏' },
            2: { id: 2, name: '离开围栏' },
        };
        this.unionStatus = params.union_status; //联合组织状态 1-处于联合状态父级组织
        this.unionOrgIds = params.union_org; //联合组织的子组织id集合
        window.CELLSYSORG = this || {}; //cellsysSDK不应该依赖于vue才能访问到cellsysOrg对象，因此引入window全局属性来缓存cellsysOrg对象

        //组织所有者的信息
        this.ownerUserId = params.owner_user_id;
        this.ownerUserMobile = params.owner_user_mobile;
        this.ownerUserRealname = params.owner_user_realname;
        this.isPublish = params.is_publish || 0;
        this.publishRange = params.publish_range; //发布范围 0-群组 1-组织
        this.publishGroup = params.publish_group ? params.publish_group : []; //发布的群组
        this.isEditable = params.is_update === 1 ? true : false; //is_update表示是否允许其他人编辑 0-不允许 1-允许
        this.isUnlock = params.is_unlock; //是否未锁定，0-已锁定，1-未锁定
        this.realname = params.realname; //

        this.dataName = params.data_name;
        this.dataType = params.data_type;
    }

    get edgeOptions() {
        let options = {
            guideStep: 'guideMemberType', //有组织的情况下向导步骤必定是最先从成员类型开始，全部完成为finish
        };
        if (this.options && this.options['edgeOptions']) {
            let _edgeOptions = this.options['edgeOptions'];
            options = {
                guideStep: _edgeOptions['guideStep'],
            };
        }
        return options;
    }

    get cloudOptions() {
        let options = {
            account: null,
            token: null,
            connectId: null,
            cloudIp: '',
            edgeNetworkIp: '',
            isConnect: false,
        };
        if (this.options && this.options['cloudOptions']) {
            let cloudOptions = this.options['cloudOptions'];
            options = {
                account: cloudOptions['account'],
                token: cloudOptions['token'],
                connectId: cloudOptions['connectId'],
                cloudIp: cloudOptions['cloudIp'],
                edgeNetworkIp: cloudOptions['egdeNetworkIp'],
                isConnect: cloudOptions['isConnect'],
            };
        }
        return options;
    }

    get mapOptions() {
        if (this.options && this.options['mapOptions']) {
            return this.options['mapOptions'];
        } else {
            return {};
        }
    }

    /**
     * 更新组织信息
     */
    updateOrg(params) {
        let editTask = new EditTask(EditType.Org_Update);
        editTask.addParam('_name', params.name);
        editTask.addParam('_unit', params.unit);
        editTask.addParam('_contact', params.contact);
        editTask.addParam('_email', params.email);
        editTask.addParam('_address', params.address);
        editTask.addParam('_description', params.description);
        editTask.addParam('_phone', params.phone);
        editTask.addParam('_logo', params.logo);
        editTask.addParam('_options', params.options);
        if (params.industryId != null) {
            editTask.addParam('_industry_id', params.industryId);
        }
        return editTask.execute();
    }

    /**
     * 更新组织配置信息（主页信息）
     */
    updateOrgOptions(params) {
        let editTask = new EditTask(EditType.Org_Options_Update);
        editTask.addParam('_options', params.options);
        if (params.keyword) {
            editTask.addParam('_keyword', params.keyword);
        }
        if (params.httpConfig) {
            editTask.setHttpConfig(params.httpConfig);
        }
        return editTask.execute();
    }

    /**
     * 更新组织行业
     */
    queryIndustry(pageInfo) {
        let query = new Query();
        let queryTask = new QueryTask(QueryType.Industry);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    resolve(res);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 获取用户信息
     */
    queryUserInfo() {
        let query = new Query();
        let queryTask = new QueryTask(QueryType.User);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res) {
                        res = new CellsysUser(res);
                        resolve(res);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据id获取用户信息
     * @param userId
     * @returns {Promise<unknown>}
     */
    queryUserInfoById(userId) {
        let query = new Query();
        query.addFilter('id', QueryType.Equals, userId);
        let queryTask = new QueryTask(QueryType.User);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res) {
                        res = new CellsysUser(res);
                        resolve(res);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 更新用户信息
     */
    updateUserInfo(params) {
        let editTask = new EditTask(EditType.User_Update);
        editTask.addParam('_mobile', params.mobile);
        editTask.addParam('_username', params.userName);
        editTask.addParam('_realname', params.realName);
        editTask.addParam('_email', params.email);
        editTask.addParam('_gender', params.gender);
        editTask.addParam('_birthday', params.birthday);
        editTask.addParam('_avatar', params.avatar);
        editTask.addParam('_is_username', 0);
        editTask.addParam('_is_mobile', 0);
        return editTask.execute();
    }

    /**
     * 修改密码
     * @param oldPassword
     * @param newPassword
     * @returns {Promise<unknown>}
     */
    updatePassword(oldPassword, newPassword) {
        let editTask = new EditTask(EditType.User_Pwd);
        editTask.addParam('_old_password', oldPassword);
        editTask.addParam('_new_password', newPassword);
        return editTask.execute();
    }

    /**
     * 解绑微信账号 _identity_type 第三方类型：wechat、qq、weibo
     * @returns {Promise<unknown>}
     */
    unbindWechat() {
        let editTask = new EditTask(EditType.User_Unbind);
        editTask.addParam('_identity_type', 'wechat');
        return editTask.execute();
    }

    /**
     * 查询用户轨迹
     * @param filters
     * @returns {Promise<unknown>}
     */
    queryUserTrajectory(filters, order) {
        let query = new Query();
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ datetime: 'asc' });
        }
        let queryTask = new QueryTask(QueryType.TrajectoryDatePath);
        return queryTask.execute(query);
    }

    /**
     * 查询组织内的所有App
     */
    queryApps(pageInfo, order, filters) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ create_time: 'desc' });
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryTask = new QueryTask(QueryType.App, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                item.orgUnionStatus = this.unionStatus; //将组织联合状态传递给cellsysApp才能在app里做相应的逻辑判断
                                return new CellsysApp(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            item.orgUnionStatus = this.unionStatus; //将组织联合状态传递给cellsysApp才能在app里做相应的逻辑判断
                            return new CellsysApp(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询已发布的app
     * @param pageInfo
     * @param order
     * @returns {Promise<unknown>}
     */
    queryAppListByPublish(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('is_publish', Operator.Equals, 1);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ model_id: 'asc', create_time: 'desc' });
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryTask = new QueryTask(QueryType.App, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                item.orgUnionStatus = this.unionStatus; //将组织联合状态传递给cellsysApp才能在app里做相应的逻辑判断
                                return new CellsysApp(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            item.orgUnionStatus = this.unionStatus; //将组织联合状态传递给cellsysApp才能在app里做相应的逻辑判断
                            return new CellsysApp(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    queryAppById(id) {
        let query = new Query();
        query.addFilter('id', Operator.Equals, id);
        let queryTask = new QueryTask(QueryType.App);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let appData = res.map((item) => {
                            item.orgUnionStatus = this.unionStatus; //将组织联合状态传递给cellsysApp才能在app里做相应的逻辑判断
                            return new CellsysApp(item);
                        });
                        resolve(appData[0]);
                    } else {
                        reject('没有app信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    createApp(app) {
        let editTask = new EditTask(EditType.App_Create);
        editTask.addParam('_name', app.name);
        editTask.addParam('_description', app.description);
        editTask.addParam('_status', app.status);
        editTask.addParam('_uri', app.uri);
        editTask.addParam('_is_show_app', app.isShowApp);
        //editTask.addParam('_is_publish', 0); //这个已经没用了下次看到可以删掉了
        editTask.addParam('_model_id', app.modelId);
        editTask.addParam('_options', app.options);
        if (app.modelOptions) {
            editTask.addParam('_model_options', app.modelOptions);
        }
        return new Promise((resolve, reject) => {
            editTask
                .execute()
                .then((res) => {
                    let cellsysApp = new CellsysApp(res.data);
                    resolve(cellsysApp);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 更新App信息
     */
    updateApp(app) {
        let editTask = new EditTask(EditType.App_Update);
        editTask.addParam('_id', app.id);
        editTask.addParam('_name', app.name);
        editTask.addParam('_description', app.description);
        editTask.addParam('_uri', app.uri);
        editTask.addParam('_is_show_app', app.isShowApp);
        editTask.addParam('_is_publish', app.isPublish);
        editTask.addParam('_options', app.options);
        editTask.addParam('_model_options', app.modelOptions);
        return editTask.execute();
    }

    /**
     * 删除App
     */
    removeApp(app) {
        let editTask = new EditTask(EditType.App_Delete);
        editTask.addParam('_id', app.id);
        return editTask.execute();
    }

    /**
     *模板在创建/修改/进入前，需要调用鉴权接口
     * @param {*}
     * @returns
     */
    OrgAppModelSelect(param) {
        let editTask = new EditTask(EditType.OrgAppModelSelect);
        editTask.addParam('_app_model_id', param);
        return editTask.execute();
    }

    /**
     * 查询组织内的所有可用模板
     */
    queryAppModels(pageInfo, filters) {
        let query = new Query();
        // query.addFilter('is_publish', Operator.Equals, 1);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        // query.addFilter('id', Operator.NotEquals, 23);//屏蔽掉查验报告模板
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ id: 'asc' });
        let queryTask = new QueryTask(QueryType.AppModel, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysAppModel(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysAppModel(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询应用模板类型
     * @returns {Promise<unknown>}
     */
    queryAppModelTypeList() {
        let query = new Query();
        query.setOrder({ id: 'asc' });
        let queryTask = new QueryTask(QueryType.AppModelType, false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (Array.isArray(res)) {
                        let result = res.map((item) => {
                            return new CellsysAppModelType(item);
                        });
                        resolve(result);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    queryAppModelById(id) {
        let query = new Query();
        query.addFilter('id', Operator.Equals, id);
        let queryTask = new QueryTask(QueryType.AppModel);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let appData = res.map((item) => {
                            return new CellsysAppModel(item);
                        });
                        resolve(appData[0]);
                    } else {
                        reject('没有模板信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * @name: ag
     * @Date: 2022-03-03 11:48:13
     * @Description: 查询组织下的所有的群组
     * @param {*} pageInfo
     * @param {*} filters
     * @param {*} getUnion 是否需要获取联合信息
     */
    queryGroups(pageInfo, filters, getUnion, order) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryType = QueryType.Group;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织，并且需要获取联合信息
            queryType = QueryType.UinonGroup;
        } else {
            query.setOrder({ org_id: 'asc', id: 'desc' });
        }
        if (order) {
            query.setOrder(order);
        }

        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysGroup(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysGroup(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * @name: ag
     * @Date: 2022-03-03 11:50:19
     * @Description: 查询已发布的群组
     * @param {*} pageInfo
     * @param {*} getUnion
     */
    queryIsPublishGroups(pageInfo, order, getUnion, httpConfig) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('is_publish', Operator.Equals, 1);
        if (httpConfig) {
            query.setHttpConfig(httpConfig);
        }
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        let queryType = QueryType.Group;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UinonGroup;
        } else {
            //联合查询父级的排序条件由后端添加
            query.setOrder({ id: 'desc' });
        }
        if (order) {
            query.setOrder(order);
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysGroup(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysGroup(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    queryGroupById(id, getUnion) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('id', Operator.Equals, id);
        let queryType = QueryType.Group;
        if (this.unionStatus === 1 && getUnion) {
            //联合状态为父级组织
            queryType = QueryType.UinonGroup;
        }
        let queryTask = new QueryTask(queryType);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let groupData = res.map((item) => {
                            return new CellsysGroup(item);
                        });
                        resolve(groupData[0]);
                    } else {
                        reject('没有群组信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询组织下的所有成员
     */
    queryOrgMembers(filters, pageInfo, getUnion, order) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ org_id: 'asc', id: 'asc', realname: 'asc' });
        }
        let queryType = QueryType.OrgMember;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionOrgMember;
        }
        let queryTask = new QueryTask(queryType, !!pageInfo);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysMember(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询申请加入组织的成员
     */
    queryOrgJoinMembers(pageInfo, filters) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ id: 'asc' });
        let queryTask = new QueryTask(QueryType.OrgJoinMember, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                item.member_type = item.member_type_id;
                                return new CellsysMember(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 审核加入组织
     * @param userId
     * @param audit true：通过，false：不通过
     * @param feedback 审核意见
     * @returns {function(): Promise<unknown>}
     */
    auditJoinOrgMember(params) {
        let { userId, audit, feedback, memberTypeId, groudIds } = params;
        let editTask = new EditTask(EditType.OrgMember_Update);
        let status = audit ? 2 : 3;
        // if(status===2){
        //     editTask.addParam('_user_id', memberType);
        // }
        editTask.addParam('_user_id', userId);
        editTask.addParam('_status', status);
        editTask.addParam('_feedback', feedback);
        if (memberTypeId) {
            editTask.addParam('_member_type_id', memberTypeId);
        }
        if (groudIds) {
            editTask.addParam('_group_ids', groudIds);
        }
        return editTask.execute();
    }

    /**
     * 移除组织成员
     * @param params 用户id集合
     * @returns {Promise | Promise<unknown>}
     */
    removeOrgMember(params) {
        let editTask = new EditTask(EditType.OrgMember_Remove);
        editTask.addParam('_user_ids', params);
        return editTask.execute();
    }

    /**
     * 退出组织
     */
    quitOrg(member) {
        let editTask = new EditTask(EditType.Org_Quit);
        editTask.addParam('_org_id', this.id);
        editTask.addParam('_user_id', member.userId);
        return editTask.execute();
    }

    /**
     *转让组织
     *
     * @returns Org_MarkOver
     */
    markOver(params) {
        let editTask = new EditTask(EditType.Org_MarkOver);
        editTask.addParam('_user_id', params);
        return editTask.execute();
    }

    /**
     * 创建群组
     */
    createGroup(group) {
        var editTask = new EditTask(EditType.Group_Create);
        editTask.addParam('_name', group.name);
        editTask.addParam('_description', group.description);
        editTask.addParam('_status', group.isPublish);
        editTask.addParam('_org_id', this.id);
        editTask.addParam('_style', group.style);
        editTask.addParam('_is_publish', group.isPublish);
        return editTask.execute();
    }

    /**
     * 更新群组信息
     */
    updateGroup(group) {
        let editTask = new EditTask(EditType.Group_Update);
        editTask.addParam('_id', group.id);
        editTask.addParam('_name', group.name);
        editTask.addParam('_status', group.status);
        editTask.addParam('_description', group.description);
        editTask.addParam('_style', group.style);
        editTask.addParam('_is_publish', group.isPublish);
        return editTask.execute();
    }

    /**
     * 删除群组
     */
    removeGroup(group) {
        let editTask = new EditTask(EditType.Group_Delete);
        editTask.addParam('_id', group.id);
        return editTask.execute();
    }

    /**
     * 查询组织下的所有成员类型
     */
    queryMemberTypes(pageInfo, filters, getUnion, order) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ org_id: 'asc', id: 'desc' });
        }

        let queryType = QueryType.MemberType;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionMemberType;
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysMemberType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMemberType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 创建成员类型
     */
    createMemberType(memberType) {
        var editTask = new EditTask(EditType.MemberType_Create);
        editTask.addParam('_name', memberType.name);
        editTask.addParam('_description', memberType.description);
        editTask.addParam('_style', memberType.style);
        return editTask.execute();
    }

    /**
     * 更新成员类型
     */
    updateMemberType(memberType) {
        let editTask = new EditTask(EditType.MemberType_Update);
        editTask.addParam('_id', memberType.id);
        editTask.addParam('_name', memberType.name);
        editTask.addParam('_style', memberType.style);
        editTask.addParam('_description', memberType.description);
        return editTask.execute();
    }

    /**
     * 删除成员类型
     */
    removeMemberType(memberType) {
        let editTask = new EditTask(EditType.MemberType_Delete);
        editTask.addParam('_id', memberType.id);
        return editTask.execute();
    }

    /**
     * 批量修改群组成员
     */
    updateGroupMembers(groupId, userIds) {
        var editTask = new EditTask(EditType.GroupMember_Update);
        editTask.addParam('_group_id', groupId);
        editTask.addParam('_user_ids', userIds);
        return editTask.execute();
    }

    /**
     * 批量修改类型成员
     */
    updateMembersByType(memberTypeId, userIds) {
        var editTask = new EditTask(EditType.MembersType_Update);
        editTask.addParam('_member_type_id', memberTypeId);
        editTask.addParam('_user_ids', userIds);
        return editTask.execute();
    }

    /**
     * 查询群组下所有成员，不包含位置信息
     * @param groupId
     * @param pageInfo
     * @returns {Promise<unknown>}
     */
    queryMembersByGroup(groupId, pageInfo, getUnion) {
        let query = new Query();
        query.addFilter('group_id', Operator.Equals, groupId);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        query.setOrder({ member_id: 'asc' });
        let queryType = QueryType.Member;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionMember;
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysMember(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据成员id查询成员信息
     * @param memberIds
     * @param pageInfo
     * @returns {Promise<unknown>}
     */
    queryMemberListById(memberIds, pageInfo) {
        let query = new Query();
        query.setOrder({ user_id: 'asc' });
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('user_id', Operator.In, memberIds);

        let queryTask = new QueryTask(QueryType.Member, !!pageInfo);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysMember(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询成员类型成员
     */
    queryMemberTypeUser(type, getUnion) {
        let query = new Query();
        query.addFilter('member_type', '=', type);
        query.setOrder({ realname: 'asc' });
        let queryType = QueryType.MemberTypeUser;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionMemberTypeUser;
        }
        let queryTask = new QueryTask(queryType, true);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.data) {
                        res.data = res.data.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(res);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据用户id查询成员的信，注：用户可以在多个群组里面，因此返回数据是数组
     * @param userId
     * @returns {Promise<Array>}
     */
    queryGroupMemberByUserId(userId, getUnion, httpConfig) {
        let query = new Query();
        query.addFilter('user_id', '=', userId);
        if (httpConfig) {
            query.setHttpConfig(httpConfig);
        }
        let queryType = QueryType.Member;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionMember;
        }
        let queryTask = new QueryTask(queryType, true);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    let data =
                        res && res.data
                            ? res.data.map((item) => {
                                  return new CellsysMember(item);
                              })
                            : [];
                    resolve(data);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询群组成员
     */
    queryGroupMembers(pageInfo, getUnion, httpConfig) {
        let query = new Query(pageInfo);
        let queryType = QueryType.Member;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionMember;
        }
        if (httpConfig) {
            query.setHttpConfig(httpConfig);
        }
        let queryTask = new QueryTask(queryType, pageInfo);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        res.data = res.data.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(res);
                    } else {
                        let data = res.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(data);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据成员类型、群组ID查询群组成员
     */
    queryGroupMemberByCondition(member_type_id, group_id, getUnion) {
        let query = new Query();
        if (member_type_id) {
            query.addFilter('member_type', Operator.Equals, member_type_id);
        }
        if (group_id) {
            query.addFilter('group_id', Operator.Equals, group_id);
        }
        query.setOrder({ realname: 'asc' });
        let queryType = QueryType.Member;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionMember;
        }
        let queryTask = new QueryTask(queryType, true);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.data) {
                        res.data = res.data.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(res);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /*queryMembersLocalByGroup(groupId, pageInfo) {
        let query = new Query();
        query.addFilter('group_id', Operator.Equals, groupId);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        query.setOrder({ datetime: 'desc' });
        let queryTask = new QueryTask(QueryType.UserLocal, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysMember(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMember(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }*/

    /**
     * 批量查询群组成员信息
     * @param groupIds
     * @returns {Promise<unknown>}
     */
    queryMembersLocalByGroups(groupIds, getUnion) {
        let query = new Query();
        query.addFilter('group_id', Operator.In, groupIds);

        let queryType = QueryType.UserLocal;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionUserLocal;
        } else {
            query.setOrder({ datetime: 'desc' });
        }
        let queryTask = new QueryTask(queryType, false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    let resArr = res.map((item) => {
                        return new CellsysMember(item);
                    });
                    resolve(resArr);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询组织下所有区域信息
     */
    queryPolygons(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        // query.setOrder({ create_time: 'desc' });
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.Polygon, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysPolygon(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysPolygon(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 创建区域
     */
    createPolygon(polygon) {
        let editTask = new EditTask(EditType.Polygon_Create);
        editTask.addParam('_name', polygon.name);
        editTask.addParam('_type', polygon.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_geom', polygon.geometry);
        editTask.addParam('_action', polygon.action);
        editTask.addParam('_buffer_distance', polygon.bufferDistance);
        editTask.addParam('_description', polygon.description);
        if (polygon.links) {
            if (polygon.links['href'].indexOf('http') === -1) {
                polygon.links['href'] = 'http://' + polygon.links['href'];
            }
            editTask.addParam('_links', [polygon.links]); //可以传数组，目前只考虑单个的情况
        }
        return editTask.execute();
    }

    /**
     * 批量创建区域
     */
    createPolygons(polygons) {
        let editTask = new EditTask(EditType.Polygon_Creates),
            paramList = [];
        if (polygons.length > 0) {
            polygons.forEach((polygon) => {
                paramList.push({
                    _name: polygon.name,
                    _geom: polygon.geometry,
                    _buffer_distance: polygon.bufferDistance,
                    _type: polygon.type,
                    _status: 1,
                    _action: polygon.action,
                    _description: polygon.description,
                });
            });
            editTask.addParam('_fences', paramList);
        }
        return editTask.execute();
    }

    /**
     * 更新区域信息
     */
    updatePolygonProperty(polygon) {
        let editTask = new EditTask(EditType.Polygon_Update_Property);
        editTask.addParam('_id', polygon.id);
        editTask.addParam('_name', polygon.name);
        editTask.addParam('_type', polygon.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_action', polygon.action);
        editTask.addParam('_buffer_distance', polygon.bufferDistance);
        editTask.addParam('_description', polygon.description);
        if (polygon.links) {
            if (polygon.links['href'].indexOf('http') === -1) {
                polygon.links['href'] = 'http://' + polygon.links['href'];
            }
            editTask.addParam('_links', [polygon.links]); //可以传数组，目前只考虑单个的情况
        } else {
            //没有链接时要置空
            editTask.addParam('_links', null);
        }
        return editTask.execute();
    }

    /**
     * 更新区域坐标和形状
     */
    updatePolygonGeometry(polygon) {
        let editTask = new EditTask(EditType.Polygon_Update_Geometry);
        editTask.addParam('_id', polygon.id);
        editTask.addParam('_geom', polygon.geometry);
        return editTask.execute();
    }

    /**
     * 删除区域
     */
    removePolygon(polygons) {
        let editTask = new EditTask(EditType.Polygon_Delete);
        let _ids = [];
        if (polygons instanceof Array === true) {
            polygons.forEach((polygon) => {
                _ids.push(polygon.id);
            });
        } else {
            _ids.push(polygons.id);
        }
        editTask.addParam('_ids', _ids);
        return editTask.execute();
    }

    /**
     * 查询组织下所有区域类型
     */
    queryPolygonTypes(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.PolygonType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysPolygonType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysPolygonType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    queryActionType() {
        return {
            1: { id: 1, name: '进入围栏' },
            2: { id: 2, name: '离开围栏' },
        };
    }

    /**
     * 创建区域类型
     */
    createPolygonType(polygonType) {
        let editTask = new EditTask(EditType.PolygonType_Create);
        editTask.addParam('_name', polygonType.name);
        editTask.addParam('_description', polygonType.description);
        editTask.addParam('_style', polygonType.style);
        return editTask.execute();
    }

    /**
     * 更新区域类型
     */
    updatePolygonType(polygonType) {
        let editTask = new EditTask(EditType.PolygonType_Update);
        editTask.addParam('_id', polygonType.id);
        editTask.addParam('_name', polygonType.name);
        editTask.addParam('_description', polygonType.description);
        editTask.addParam('_style', polygonType.style);
        editTask.addParam('_is_publish', polygonType.isPublish);
        return editTask.execute();
    }

    /**
     * 删除区域类型
     */
    removePolygonType(polygonType) {
        let editTask = new EditTask(EditType.PolygonType_Delete);
        editTask.addParam('_id', polygonType.id);
        return editTask.execute();
    }

    /**
     * 清空指定区域类型数据
     */
    removePolygonsType(polygonType) {
        let editTask = new EditTask(EditType.PolygonsType_Delete);
        editTask.addParam('_id', polygonType.id);
        return editTask.execute();
    }

    /**
     * 查询组织下所有标记信息
     */
    queryMarkers(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.Marker, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysMark(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMark(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    queryMarkerById(id) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('id', Operator.Equals, id);
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.Marker);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    let resArr = [];
                    if (res && res.length > 0) {
                        resArr = res.map((item) => {
                            return new CellsysMark(item);
                        });
                    }
                    resolve(resArr);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 创建标记
     */
    createMarker(marker) {
        let editTask = new EditTask(EditType.Marker_Create);
        editTask.addParam('_name', marker.name);
        editTask.addParam('_geom', marker.geometry);
        editTask.addParam('_buffer_distance', marker.bufferDistance);
        editTask.addParam('_radius', marker.radius);
        editTask.addParam('_type', marker.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_action', marker.action);
        editTask.addParam('_description', marker.description);
        if (marker.links) {
            if (marker.links['href'].indexOf('http') === -1) {
                marker.links['href'] = 'http://' + marker.links['href'];
            }
            editTask.addParam('_links', [marker.links]); //可以传数组，目前只考虑单个的情况
        }
        return editTask.execute();
    }

    /**
     * 批量创建标记
     */
    createMarkers(markers) {
        let editTask = new EditTask(EditType.Markers_Create),
            paramList = [];
        if (markers.length > 0) {
            markers.forEach((marker) => {
                paramList.push({
                    _name: marker.name,
                    _geom: marker.geometry,
                    _buffer_distance: marker.bufferDistance,
                    _radius: marker.radius,
                    _type: marker.type,
                    _status: 1,
                    _action: marker.action,
                    _description: marker.description,
                });
            });
            editTask.addParam('_fence_points', paramList);
        }
        return editTask.execute();
    }

    /**
     * 更新标记属性
     */
    updateMarkerProperty(marker) {
        let editTask = new EditTask(EditType.Marker_Update_Property);
        editTask.addParam('_id', marker.id);
        editTask.addParam('_name', marker.name);
        editTask.addParam('_type', marker.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_description', marker.description);
        editTask.addParam('_radius', marker.radius);
        editTask.addParam('_action', marker.action);
        editTask.addParam('_buffer_distance', marker.bufferDistance);
        if (marker.links) {
            if (marker.links['href'].indexOf('http') === -1) {
                marker.links['href'] = 'http://' + marker.links['href'];
            }
            editTask.addParam('_links', [marker.links]); //可以传数组，目前只考虑单个的情况
        } else {
            //没有链接时要置空
            editTask.addParam('_links', null);
        }
        return editTask.execute();
    }

    /**
     * 更新标记图形和位置信息
     */
    updateMarkerGeometry(marker) {
        let editTask = new EditTask(EditType.Marker_Update_Geometry);
        editTask.addParam('_id', marker.id);
        editTask.addParam('_geom', marker.geometry);
        return editTask.execute();
    }

    /**
     * 删除标记
     */
    removeMarker(markers) {
        let editTask = new EditTask(EditType.Marker_Delete);
        let _ids = [];
        if (markers instanceof Array === true) {
            markers.forEach((marker) => {
                _ids.push(marker.id);
            });
        } else {
            _ids.push(markers.id);
        }
        editTask.addParam('_ids', _ids);
        return editTask.execute();
    }

    /**
     * 查询组织下的所有标记类型
     */
    queryMarkerType(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.MarkerType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysMarkType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysMarkType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 标记类型
     */
    createMarkerType(markerType) {
        let editTask = new EditTask(EditType.MarkerType_Create);
        editTask.addParam('_name', markerType.name);
        editTask.addParam('_description', markerType.description);
        editTask.addParam('_style', markerType.style);
        return editTask.execute();
    }

    updateMarkerType(markerType) {
        let editTask = new EditTask(EditType.MarkerType_Update);
        editTask.addParam('_id', markerType.id);
        editTask.addParam('_name', markerType.name);
        editTask.addParam('_style', markerType.style);
        editTask.addParam('_description', markerType.description);
        editTask.addParam('_action', markerType.action);
        editTask.addParam('_is_publish', markerType.isPublish);
        return editTask.execute();
    }

    removeMarkerType(markerType) {
        let editTask = new EditTask(EditType.MarkerType_Delete);
        editTask.addParam('_id', markerType.id);
        return editTask.execute();
    }

    /**
     * 清空指定标记类型数据
     * @param markerType
     * @returns {Promise<unknown>}
     */
    removeMarkersType(markerType) {
        let editTask = new EditTask(EditType.MarkersType_Delete);
        editTask.addParam('_id', markerType.id);
        return editTask.execute();
    }

    /**
     * 路线
     */
    queryLines(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.Line, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysLine(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysLine(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    createLine(line) {
        let editTask = new EditTask(EditType.Line_Create);
        editTask.addParam('_name', line.name);
        editTask.addParam('_type', line.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_geom', line.geometry);
        editTask.addParam('_action', line.action);
        editTask.addParam('_buffer_distance', line.bufferDistance);
        editTask.addParam('_radius', line.radius);
        editTask.addParam('_description', line.description);
        if (line.links) {
            if (line.links['href'].indexOf('http') === -1) {
                line.links['href'] = 'http://' + line.links['href'];
            }
            editTask.addParam('_links', [line.links]); //可以传数组，目前只考虑单个的情况
        }
        return editTask.execute();
    }

    //批量导入
    createLines(lines) {
        let editTask = new EditTask(EditType.Line_Creates),
            paramList = [];
        if (lines.length > 0) {
            lines.forEach((line) => {
                paramList.push({
                    _name: line.name,
                    _geom: line.geometry,
                    _buffer_distance: line.bufferDistance,
                    _type: line.type,
                    _status: 1,
                    _action: line.action,
                    _description: line.description,
                });
            });
            editTask.addParam('_fence_lines', paramList);
        }
        return editTask.execute();
    }

    updateLineProperty(line) {
        let editTask = new EditTask(EditType.Line_Update_Property);
        editTask.addParam('_id', line.id);
        editTask.addParam('_name', line.name);
        editTask.addParam('_type', line.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_action', line.action);
        editTask.addParam('_buffer_distance', line.bufferDistance);
        editTask.addParam('_radius', line.radius);
        editTask.addParam('_description', line.description);
        if (line.links) {
            if (line.links['href'].indexOf('http') === -1) {
                line.links['href'] = 'http://' + line.links['href'];
            }
            editTask.addParam('_links', [line.links]); //可以传数组，目前只考虑单个的情况
        } else {
            //没有链接时要置空
            editTask.addParam('_links', null);
        }
        return editTask.execute();
    }

    updateLineGeometry(line) {
        let editTask = new EditTask(EditType.Line_Update_Geometry);
        editTask.addParam('_id', line.id);
        editTask.addParam('_geom', line.geometry);
        return editTask.execute();
    }

    removeLine(lines) {
        let editTask = new EditTask(EditType.Line_Delete);
        let _ids = [];
        if (lines instanceof Array === true) {
            lines.forEach((line) => {
                _ids.push(line.id);
            });
        } else {
            _ids.push(lines.id);
        }
        editTask.addParam('_ids', _ids);
        return editTask.execute();
    }

    /**
     * 路线类型
     */
    queryLineTypes(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.LineType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysLineType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysLineType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 新增路线类型
     * @param lineType
     */
    createLineType(lineType) {
        let editTask = new EditTask(EditType.LineType_Create);
        editTask.addParam('_name', lineType.name);
        editTask.addParam('_description', lineType.description);
        editTask.addParam('_style', lineType.style);
        return editTask.execute();
    }

    /**
     * 修改路线类型
     * @param lineType
     */
    updateLineType(lineType) {
        let editTask = new EditTask(EditType.LineType_Update);
        editTask.addParam('_id', lineType.id);
        editTask.addParam('_name', lineType.name);
        editTask.addParam('_style', lineType.style);
        editTask.addParam('_description', lineType.description);
        editTask.addParam('_is_publish', lineType.isPublish);
        return editTask.execute();
    }

    removeLineType(lineType) {
        let editTask = new EditTask(EditType.LineType_Delete);
        editTask.addParam('_id', lineType.id);
        return editTask.execute();
    }

    /**
     * 清空指定路线类型数据
     * @param lineType
     * @returns {Promise<unknown>}
     */
    removeLinesType(lineType) {
        let editTask = new EditTask(EditType.LinesType_Delete);
        editTask.addParam('_id', lineType.id);
        return editTask.execute();
    }

    /**
     * 查询组织下的所有专题信息
     */
    queryLayerGroups(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.LayerGroup, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysLayerGroup(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysLayerGroup(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询已发布的
     * @param pageInfo
     * @returns {Promise<unknown>}
     */
    queryIsPublishLayerGroups(pageInfo, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('is_publish', Operator.Equals, 1);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }
        let queryTask = new QueryTask(QueryType.LayerGroup, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysLayerGroup(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysLayerGroup(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据id查询专题信息
     * @param id
     * @returns {Promise<unknown>}
     */
    queryLayerGroupById(id) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('id', Operator.Equals, id);
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.LayerGroup);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let appData = res.map((item) => {
                            return new CellsysLayerGroup(item);
                        });
                        resolve(appData[0]);
                    } else {
                        reject('没有专题信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    createLayerGroup(layerGroup) {
        let editTask = new EditTask(EditType.LayerGroup_Create);
        editTask.addParam('_name', layerGroup.name);
        editTask.addParam('_description', layerGroup.description);
        editTask.addParam('_options', layerGroup.options);
        //editTask.addParam('_is_publish', layerGroup.isPublish);
        return editTask.execute();
    }

    updateLayerGroup(layerGroup) {
        let editTask = new EditTask(EditType.LayerGroup_Update);
        editTask.addParam('_id', layerGroup.id);
        editTask.addParam('_name', layerGroup.name);
        editTask.addParam('_description', layerGroup.description);
        editTask.addParam('_options', layerGroup.options);
        editTask.addParam('_is_publish', layerGroup.isPublish);
        return editTask.execute();
    }

    removeLayerGroup(layerGroup) {
        let editTask = new EditTask(EditType.LayerGroup_Delete);
        editTask.addParam('_id', layerGroup.id);
        return editTask.execute();
    }

    /**
     * 查询组织下所有图层信息
     */
    queryLayers(pageInfo, filters) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        // query.addFilter('data_param', Operator.Equals, { type: 73 });
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.LayerBasic, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysLayer(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysLayer(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据专题id查询专题下的图层
     * @param layerId
     * @returns {Promise<unknown>}
     */
    queryLayersByGroupId(layerId) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('layer_group_id', Operator.Equals, layerId);
        query.setOrder({ legend_order: 'asc' });
        let queryTask = new QueryTask(QueryType.Layer);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    const data = res.map((o) => {
                        return new CellsysLayer(o);
                    });
                    resolve(data);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 批量查询专题图层
     * @param layerIds
     * @returns {Promise<unknown>}
     */
    queryLayersByGroupIds(layerIds) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('layer_group_id', Operator.In, layerIds);
        query.setOrder({ legend_order: 'asc' });
        let queryTask = new QueryTask(QueryType.Layer);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    const data = res.map((o) => {
                        return new CellsysLayer(o);
                    });
                    resolve(data);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    queryLayersByName(name) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('name', Operator.Like, name);
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.LayerBasic);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let appData = res.map((item) => {
                            return new CellsysLayer(item);
                        });
                        resolve(appData);
                    } else {
                        resolve();
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    createLayer(layer) {
        let editTask = new EditTask(EditType.Layer_Create);
        editTask.addParam('_name', layer.layerName);
        editTask.addParam('_description', layer.description);
        editTask.addParam('_geometry_type', layer.geometryType);
        editTask.addParam('_data_url', layer.dataUrl);
        editTask.addParam('_style', layer.style);
        editTask.addParam('_type', layer.type);
        editTask.addParam('_data_api', layer.dataApi);
        editTask.addParam('_data_param', layer.dataParam);
        return editTask.execute();
    }

    /**
     * 批量新增图层   20200708 yw
     * @param layers
     * @returns {Promise<unknown>}
     */
    createLayers(layers) {
        const editTask = new EditTask(EditType.Layer_BatchCreate);
        const _layers = layers.map((o) => {
            return {
                _name: o.layerName,
                _description: o.description,
                _geometry_type: o.geometryType,
                _data_url: o.dataUrl,
                _style: o.style,
                _type: o.type,
                _data_api: o.dataApi,
                _data_param: o.dataParam,
            };
        });
        editTask.addParam('_layers', _layers);
        return editTask.execute();
    }

    updateLayer(layer) {
        let editTask = new EditTask(EditType.Layer_Update);
        editTask.addParam('_id', layer.id);
        editTask.addParam('_name', layer.layerName);
        editTask.addParam('_description', layer.description);
        editTask.addParam('_geometry_type', layer.geometryType);
        editTask.addParam('_data_url', layer.dataUrl);
        editTask.addParam('_style', layer.style);
        editTask.addParam('_type', layer.type);
        editTask.addParam('_data_api', layer.dataApi);
        editTask.addParam('_data_param', layer.dataParam);
        return editTask.execute();
    }

    removeLayer(layer) {
        let editTask = new EditTask(EditType.Layer_Delete);
        editTask.addParam('_id', layer.id);
        return editTask.execute();
    }

    getLayerTypes() {
        return [
            { geometryType: 0, name: '标记' },
            { geometryType: 1, name: '路线' },
            { geometryType: 2, name: '区域' },
        ];
    }

    /**
     * 查询组织下的所有事件信息
     */
    queryEvents(pageInfo, filters, getUnion, order) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                if (item['type']) {
                    query.addFilter(item['name'], item['operator'], item['value'], item['type']);
                } else {
                    query.addFilter(item['name'], item['operator'], item['value']);
                }
            });
        }

        let queryType = QueryType.Event;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionEvent;
        }
        if (order) {
            query.setOrder(order);
        } else {
            //事件因为带有时间属性，所以默认应该是时间升序
            query.setOrder({ datetime: 'asc' });
        }

        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEvent(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEvent(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 批量查询事件
     * @param ids
     * @returns {Promise<unknown>}
     */
    queryEventByIds(ids, getUnion) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        query.setOrder({ datetime: 'asc', org_id: 'asc' });
        query.addFilter('type', Operator.In, ids);
        let queryType = QueryType.Event;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionEvent;
        }
        let queryTask = new QueryTask(queryType, false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    resolve(
                        res.map((item) => {
                            return new CellsysEvent(item);
                        }),
                    );
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    createEvent(event) {
        let editTask = new EditTask(EditType.Event_Create);
        editTask.addParam('_name', event.name);
        editTask.addParam('_description', event.description);
        editTask.addParam('_type', event.type);
        editTask.addParam('_datetime', event.dateTime);
        if (event.links) {
            if (event.links['href'].indexOf('http') === -1) {
                event.links['href'] = 'http://' + event.links['href'];
            }
            editTask.addParam('_links', [event.links]); //可以传数组，目前只考虑单个的情况
        }
        //editTask.addParam('_pictures', event.pictures); //新增时不传图片，只生成事件记录
        editTask.addParam('_geom', event.geometry);
        return editTask.execute();
    }

    updateEvent(event) {
        let editTask = new EditTask(EditType.Event_Update);
        editTask.addParam('_id', event.id);
        editTask.addParam('_name', event.name);
        editTask.addParam('_description', event.description);
        editTask.addParam('_type', event.type);
        if (event.links) {
            if (event.links['href'].indexOf('http') === -1) {
                event.links['href'] = 'http://' + event.links['href'];
            }
            editTask.addParam('_links', [event.links]); //可以传数组，目前只考虑单个的情况
        } else {
            //没有链接时要置空
            editTask.addParam('_links', null);
        }
        editTask.addParam('_datetime', event.dateTime);
        //editTask.addParam('_pictures', event.pictures); 文件流上传不再传此参数
        let eventImages = event.eventImages;
        let _img_path = [],
            _litimg_path = [],
            _file_path = [];
        for (let item of eventImages) {
            let fileNameSplit = item['imgPath'].split('/');
            if (fileNameSplit.length > 0) {
                let fileName = fileNameSplit.at(-1); //取数组最后一位
                _file_path.push(fileName);
            }
            _img_path.push(item['imgPath']);
            _litimg_path.push(item['litimgPath']);
        }
        editTask.addParam('_file_path', _file_path);
        editTask.addParam('_img_paths', _img_path);
        editTask.addParam('_litimg_paths', _litimg_path);
        editTask.addParam('_geom', event.geometry);
        return editTask.execute();
    }

    removeEvent(event) {
        let editTask = new EditTask(EditType.Event_Delete);
        editTask.addParam('_id', event.id);
        return editTask.execute();
    }

    /**
     *
     */
    EventTypeLock(params) {
        let editTask = new EditTask(EditType.eventTypeLock);
        editTask.addParam('_id', params.id);
        editTask.addParam('_is_unlock', params.isUnlock);
        return editTask.execute();
    }

    /**
     * 查询组织下的所有事件类型
     */
    queryEventTypes(pageInfo, filters, getUnion, order) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryType = QueryType.EventType;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionEventType;
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }
        // else {
        //     query.setOrder({ is_publish: 'desc', id: 'desc', });
        // }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEventType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEventType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询已发布的事件类型
     * @param pageInfo
     * @returns {Promise<unknown>}
     */
    queryIsPublishEvenTypes(pageInfo, order, getUnion) {
        let query = new Query();
        query.addFilter('is_publish', Operator.Equals, 1);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        let queryType = QueryType.EventType;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionEventType;
        } else {
            //联合的组织排序必须由后端排
            query.setOrder({ id: 'desc' });
        }
        if (order) {
            query.setOrder(order);
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEventType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEventType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    createEventType(eventType) {
        let editTask = new EditTask(EditType.EventType_Create);
        editTask.addParam('_name', eventType.name);
        editTask.addParam('_description', eventType.description);
        editTask.addParam('_style', eventType.style);
        return editTask.execute();
    }

    updateEventType(eventType) {
        let editTask = new EditTask(EditType.EventType_Update);
        editTask.addParam('_id', eventType.id);
        editTask.addParam('_name', eventType.name);
        editTask.addParam('_style', eventType.style);
        editTask.addParam('_description', eventType.description);
        editTask.addParam('_is_publish', eventType.isPublish);
        return editTask.execute();
    }

    removeEventType(eventType) {
        let editTask = new EditTask(EditType.EventType_Delete);
        editTask.addParam('_id', eventType.id);
        return editTask.execute();
    }

    /**
     * 查询组织下的所有设备类型
     */
    queryEquipmentType(pageInfo, filters, getUnion, order) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryType = QueryType.OrgEquipmentType;
        if (this.unionStatus === 1 && getUnion === true) {
            queryType = QueryType.UnionOrgEquipmentType;
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ is_publish: 'desc' });
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEquipmentType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEquipmentType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询已发布的设备类型
     * @param pageInfo
     * @param filters
     * @returns {Promise<unknown>}
     */
    queryIsPublishEquipmentTypeList(pageInfo, filters, order, getUnion) {
        let query = new Query();
        //query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        query.addFilter('is_publish', Operator.Equals, 1);
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryType = QueryType.OrgEquipmentType;
        if (this.unionStatus === 1 && getUnion === true) {
            queryType = QueryType.UnionOrgEquipmentType;
        } else {
            query.setOrder({ id: 'desc' });
        }
        if (order) {
            query.setOrder(order);
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEquipmentType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEquipmentType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    // 添加组织的设备类型
    createEquipmentType(equipmentType) {
        let editTask = new EditTask(EditType.EquipmentType_Create);
        editTask.addParam('_type', equipmentType.type);
        editTask.addParam('_name', equipmentType.name);
        editTask.addParam('_description', equipmentType.description);
        editTask.addParam('_style', equipmentType.style);
        //editTask.addParam('_is_publish', equipmentType.isPublish);
        return editTask.execute();
    }

    // 修改组织的设备类型
    updateEquipmentType(equipmentType) {
        let editTask = new EditTask(EditType.EquipmentType_Update);
        editTask.addParam('_id', equipmentType.id);
        editTask.addParam('_type', equipmentType.type);
        editTask.addParam('_name', equipmentType.name);
        editTask.addParam('_description', equipmentType.description);
        editTask.addParam('_style', equipmentType.style);
        editTask.addParam('_is_publish', equipmentType.isPublish);
        return editTask.execute();
    }

    // 删除组织的设备类型
    removeEquipmentType(equipmentType) {
        let editTask = new EditTask(EditType.EquipmentType_Delete);
        editTask.addParam('_type', equipmentType.type);
        editTask.addParam('_id', equipmentType.id); //组织设备类型id
        editTask.addParam('_confirm', equipmentType.confirm); //是否一键解绑并删除设备类型下的所有设备
        return editTask.execute();
    }

    /**
     * 查询监控量
     * @param filters
     * @returns {Promise<unknown>}
     */
    queryEquipmentTypeMonitorList(filters) {
        let query = new Query();
        // query.addFilter('org_id', Operator.E
        // quals, this.id)
        if (filters) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ create_time: 'desc' });
        let queryTask = new QueryTask(QueryType.EquipmentTypeMonitors, false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    let resArr = res.map((item) => {
                        return new CellsysEquipmentMonitor(item);
                    });
                    resolve(resArr);
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询组织下的所有设备
     */
    queryEquipment(pageInfo, filters, getUnion, order) {
        let query = new Query();
        //query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryType = QueryType.Equipment;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionEquipment;
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEquipment(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEquipment(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据设备Id查询设备
     */
    queryEquipmentById(id) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('id', Operator.Equals, id);
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.Equipment);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let equData = res.map((item) => {
                            return new CellsysEquipment(item);
                        });
                        resolve(equData[0]);
                    } else {
                        reject('没有设备信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据macid查询设备详情
     * @param macid
     * @returns {Promise<unknown>}
     */
    queryEquipmentByMacId(macid, getUnion) {
        let query = new Query();
        //query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('macid', Operator.Equals, macid);

        let queryType = QueryType.Equipment;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionEquipment;
        } else {
            query.setOrder({ id: 'desc' });
        }
        let queryTask = new QueryTask(queryType);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let equData = res.map((item) => {
                            return new CellsysEquipment(item);
                        });
                        resolve(equData[0]);
                    } else {
                        reject('没有设备信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据多个设备id查询设备信息
     * @param typeIds
     * @returns {Promise<unknown>}
     */
    queryEquipmentByTypeIds(typeIds, getUnion) {
        let query = new Query();
        //query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('type_id', Operator.In, typeIds);
        let queryType = QueryType.Equipment;
        if (this.unionStatus === 1 && getUnion === true) {
            //联合状态为父级组织
            queryType = QueryType.UnionEquipment;
        } else {
            query.setOrder({ id: 'desc' });
        }
        let queryTask = new QueryTask(queryType);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    resolve(
                        res.map((item) => {
                            return new CellsysEquipment(item);
                        }),
                    );
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据用户查询设备信息
     * @param pageInfo
     * @param filters
     * @returns {Promise<unknown>}
     */
    queryUserEquipment(filters, pageInfo, getUnion) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }

        let queryType = QueryType.EquipmentUser;
        if (this.unionStatus === 1 && getUnion === true) {
            queryType = QueryType.UnionEquipmentUser;
        } else {
            query.setOrder({ create_time: 'desc' });
        }
        let queryTask = new QueryTask(queryType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEquipment(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEquipment(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据类型查询当前登录用户绑定的设备
     * @param typeId
     * @param filters
     * @returns {Promise<unknown>}
     */
    queryUserEquipmentByType(typeId, filters) {
        let query = new Query();
        // query.addFilter('org_id', Operator.Equals, this.id)
        query.addFilter('type', Operator.Equals, typeId);
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.EquipmentUser);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    resolve(
                        res.map((item) => {
                            return new CellsysEquipment(item);
                        }),
                    );
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据多个设备id查询设备信息
     * @param typeIds
     * @param filters
     * @returns {Promise<unknown>}
     */
    queryUserEquipmentListByTypes(typeIds, filters) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('type_id', Operator.In, typeIds);
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.EquipmentUser);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        resolve(res);
                    } else {
                        reject(new Error('没有设备信息'));
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据id查询设备信息
     * @param id
     * @returns {Promise<unknown>}
     */
    queryUserEquipmentById(id) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('id', Operator.Equals, id);
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.EquipmentUser);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let equData = res.map((item) => {
                            return new CellsysEquipment(item);
                        });
                        resolve(equData[0]);
                    } else {
                        reject('没有设备信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据id批量查询设备
     * @param ids
     * @returns {Promise<unknown>}
     */
    queryUserEquipmentByIds(ids) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('id', Operator.In, ids);
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.EquipmentUser);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (res.length > 0) {
                        let equData = res.map((item) => {
                            return new CellsysEquipment(item);
                        });
                        resolve(equData);
                    } else {
                        reject('没有设备信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    createEquipment(equipment) {
        let editTask = new EditTask(EditType.Equipment_Create);
        editTask.addParam('_name', equipment.name);
        editTask.addParam('_type', equipment.type);
        editTask.addParam('_macid', equipment.macId);
        editTask.addParam('_description', equipment.description);
        editTask.addParam('_rd_number', equipment.rdNumber);
        editTask.addParam('_status', 1);
        return editTask.execute();
    }

    updateEquipment(equipment) {
        let editTask = new EditTask(EditType.Equipment_Update);
        editTask.addParam('_id', equipment.id);
        editTask.addParam('_name', equipment.name);
        editTask.addParam('_description', equipment.description);
        editTask.addParam('_rd_number', equipment.rdNumber);
        editTask.addParam('_status', 1);
        return editTask.execute();
    }

    // 删除设备
    removeEquipment(equipment) {
        let editTask = new EditTask(EditType.Equipment_Delete);
        editTask.addParam('_id', equipment.id);
        // editTask.addParam('_confirm', equipment.confirm)
        return editTask.execute();
    }

    /**
     * 查询组织用户已绑设备列表
     */
    queryEquipmentUser(pageInfo, filters) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.EquipmentUser, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEquipmentUser(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEquipmentUser(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    // 绑定设备
    bindEquipment(macId, userId) {
        let editTask = new EditTask(EditType.EquipmentUser_Create);
        editTask.addParam('_macid', macId);
        editTask.addParam('_user_id', userId);
        return editTask.execute();
    }

    // 解绑设备
    unbindEquipment(macId, userId) {
        let editTask = new EditTask(EditType.EquipmentUser_Delete);
        editTask.addParam('_macid', macId);
        editTask.addParam('_user_id', userId);
        return editTask.execute();
    }

    /**
     * 批量查询事件类型的事件
     * @param types
     * @param pageInfo
     * @returns {Promise<unknown>}
     */
    queryEventByTypes(types, pageInfo, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (types && types.length > 0) {
            query.addFilter('type', Operator.In, types);
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }
        let queryTask = new QueryTask(QueryType.Event, !!pageInfo);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysEvent(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysEvent(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询所有围栏事件信息
     */
    queryFenceEvents(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ datetime: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.FenceEvent, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysFenceEvent(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysFenceEvent(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 根据围栏id查询当前app下的围栏事件
     */
    queryFenceEventsById(pageInfo, fenceIds) {
        let query = new Query();
        // query.addFilter("org_id", Operator.Equals, this.orgId);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (fenceIds && fenceIds.length > 0) {
            query.addFilter('fence_id', Operator.In, fenceIds);
        }
        query.setOrder({ datetime: 'desc' });
        let queryTask = new QueryTask(QueryType.FenceEvent, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysFenceEvent(item);
                            });
                            resolve(res);
                        }
                    } else {
                        // let resArr = res.map(item => {
                        //     return new CellsysFenceEvent(item);
                        // })
                        // resolve(resArr);
                        reject('没有围栏事件信息');
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /***
     * 新增任务
     */
    createTask(task) {
        let editTask = new EditTask(EditType.Task_Create);
        editTask.addParam('_name', task.name);
        editTask.addParam('_task_type_id', 1); //任务操作类型
        editTask.addParam('_description', task.description);
        editTask.addParam('_is_public', 1); //是否公开
        // editTask.addParam('_status', task.status)
        editTask.addParam('_start_time', task.startTime);
        editTask.addParam('_end_time', task.endTime);
        // editTask.addParam('_finish_time', null)
        editTask.addParam('_user_ids', task.userIds);
        editTask.addParam('_task_group_ids', task.groupIds);
        editTask.addParam('_task_geometry_ids', task.geometryIds);
        editTask.addParam('_task_type_custom_id', task.taskTypeCustomId);
        return editTask.execute();
    }

    /**
     * 更新任务
     */
    updateTask(task) {
        let editTask = new EditTask(EditType.Task_Update);
        editTask.addParam('_id', task.id);
        editTask.addParam('_name', task.name);
        editTask.addParam('_task_type_id', 1);
        editTask.addParam('_is_public', 1);
        editTask.addParam('_description', task.description);
        // editTask.addParam('_status', task.status)
        editTask.addParam('_start_time', task.startTime);
        editTask.addParam('_end_time', task.endTime);
        // editTask.addParam('_finish_time', null)
        editTask.addParam('_user_ids', task.userIds);
        editTask.addParam('_task_group_ids', task.groupIds);
        editTask.addParam('_task_geometry_ids', task.geometryIds);
        editTask.addParam('_task_type_custom_id', task.taskTypeCustomId);
        return editTask.execute();
    }

    /**
     * 删除任务
     */
    deleteTask(task) {
        let editTask = new EditTask(EditType.Task_Delete);
        editTask.addParam('_id', task.id);
        return editTask.execute();
    }

    /**
     * 查询任务列表
     */
    queryTaskList(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ start_time: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.Task, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysTask(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysTask(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询任务图形列表
     */
    queryTaskGromList(pageInfo, filters) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ id: 'desc' });
        let queryTask = new QueryTask(QueryType.TaskGeom, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysTaskGeom(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysTaskGeom(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 查询任务关联的图形 20200628 yw
     * @param id
     * @returns {Promise<unknown>}
     */
    queryTaskGeomRelById(id) {
        const query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        query.addFilter('task_id', Operator.Equals, id);
        query.setOrder({ task_id: 'desc' });
        const queryTask = new QueryTask(QueryType.TaskGeomRel, false);
        return queryTask.execute(query);
    }

    /***
     * 新增任务图形列表
     */
    createTaskGeom(taskGeom) {
        let editTask = new EditTask(EditType.TaskGeom_Create);
        editTask.addParam('_name', taskGeom.name);
        editTask.addParam('_description', taskGeom.description);
        editTask.addParam('_geom_type', taskGeom.geomType);
        editTask.addParam('_geom', taskGeom.geometry);
        // editTask.addParam('_buffer_distance', taskGeom.bufferDistance)
        // editTask.addParam('_action', taskGeom.action)
        // editTask.addParam('_status', taskGeom.status)
        return editTask.execute();
    }

    /***
     * 导入任务图形列表
     */
    importTaskGeom(taskGeom) {
        let editTask = new EditTask(EditType.TaskGeom_Import);
        editTask.addParam('_object', taskGeom.object);
        editTask.addParam('_object_ids', taskGeom.objectIds);
        return editTask.execute();
    }

    /***
     * 更新任务图形
     */
    updateTaskGeom(taskGeom) {
        let editTask = new EditTask(EditType.TaskGeom_Update);
        editTask.addParam('_id', taskGeom.id);
        editTask.addParam('_name', taskGeom.name);
        editTask.addParam('_description', taskGeom.description);
        editTask.addParam('_geom_type', taskGeom.geomType);
        editTask.addParam('_geom', taskGeom.geometry);
        // editTask.addParam('_buffer_distance', taskGeom.bufferDistance)
        // editTask.addParam('_action', taskGeom.action)
        // editTask.addParam('_status', taskGeom.status)
        return editTask.execute();
    }

    /***
     * 更新任务图形列表
     */
    removeTaskGeom(taskGeom) {
        let editTask = new EditTask(EditType.TaskGeom_Delete);
        editTask.addParam('_id', taskGeom.id);
        return editTask.execute();
    }

    /**
     * 查询任务类型列表
     */
    queryTaskTypeList(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.TaskType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysTaskType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysTaskType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /***
     * 新增任务类型列表
     */
    createTaskType(taskType) {
        let editTask = new EditTask(EditType.TaskType_Create);
        editTask.addParam('_name', taskType.name);
        editTask.addParam('_description', taskType.description);
        editTask.addParam('_is_publish', taskType.isPublish);
        return editTask.execute();
    }

    /***
     * 更新任务类型列表
     */
    updateTaskType(taskType) {
        let editTask = new EditTask(EditType.TaskType_Update);
        editTask.addParam('_id', taskType.id);
        editTask.addParam('_name', taskType.name);
        editTask.addParam('_description', taskType.description);
        editTask.addParam('_is_publish', taskType.isPublish);
        return editTask.execute();
    }

    /***
     * 更新任务类型列表
     */
    removeTaskType(taskType) {
        let editTask = new EditTask(EditType.TaskType_Delete);
        editTask.addParam('_id', taskType.id);
        return editTask.execute();
    }

    /**
     * 查询组织下所有离线区域信息
     */
    queryOfflinePolygons(pageInfo, filters, order, httpConfig) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }
        if (httpConfig) {
            query.setHttpConfig(httpConfig);
        }
        let queryTask = new QueryTask(QueryType.OfflinePolygon, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysOfflinePolygon(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysOfflinePolygon(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 创建离线区域
     */
    createOfflinePolygon(polygon) {
        let editTask = new EditTask(EditType.OfflinePolygon_Create);
        editTask.addParam('_name', polygon.name);
        editTask.addParam('_type', polygon.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_geom', polygon.geometry);
        editTask.addParam('_action', polygon.action);
        editTask.addParam('_buffer_distance', polygon.bufferDistance);
        editTask.addParam('_description', polygon.description);
        return editTask.execute();
    }

    /**
     * 批量创建离线区域
     */
    createOfflinePolygons(polygons) {
        let editTask = new EditTask(EditType.OfflinePolygon_Creates),
            paramList = [];
        if (polygons.length > 0) {
            polygons.forEach((polygon) => {
                paramList.push({
                    _name: polygon.name,
                    _geom: polygon.geometry,
                    _buffer_distance: polygon.bufferDistance,
                    _type: polygon.type,
                    _status: 1,
                    _action: polygon.action,
                    _description: polygon.description,
                });
            });
            editTask.addParam('_offline_fences', paramList);
        }
        return editTask.execute();
    }

    /**
     * 更新离线区域信息
     */
    updateOfflinePolygonProperty(polygon) {
        let editTask = new EditTask(EditType.OfflinePolygon_Update_Property);
        editTask.addParam('_id', polygon.id);
        editTask.addParam('_name', polygon.name);
        editTask.addParam('_type', polygon.type);
        editTask.addParam('_status', 1);
        editTask.addParam('_action', polygon.action);
        editTask.addParam('_buffer_distance', polygon.bufferDistance);
        editTask.addParam('_description', polygon.description);
        return editTask.execute();
    }

    /**
     * 更新离线区域坐标和形状
     */
    updateOfflinePolygonGeometry(polygon) {
        let editTask = new EditTask(EditType.OfflinePolygon_Update_Geometry);
        editTask.addParam('_id', polygon.id);
        editTask.addParam('_geom', polygon.geometry);
        return editTask.execute();
    }

    /**
     * 删除离线区域
     */
    removeOfflinePolygon(polygons) {
        let editTask = new EditTask(EditType.OfflinePolygon_Delete);
        let _ids = [];
        if (polygons instanceof Array === true) {
            polygons.forEach((polygon) => {
                _ids.push(polygon.id);
            });
        } else {
            _ids.push(polygons.id);
        }
        editTask.addParam('_ids', _ids);
        return editTask.execute();
    }

    /**
     * 生成离线区域的地图切片数据
     */
    createOfflinePolygonMapTile(polygon) {
        let editTask = new EditTask(EditType.OfflinePolygon_Create_MapTile);
        editTask.addParam('_id', polygon.id);
        return editTask.execute();
    }

    /**
     * 查询组织下所有离线区域类型信息
     */
    queryOfflinePolygonTypes(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.OfflinePolygonType, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysOfflinePolygonType(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysOfflinePolygonType(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    /**
     * 创建离线区域类型
     */
    createOfflinePolygonType(polygonType) {
        let editTask = new EditTask(EditType.OfflinePolygonType_Create);
        editTask.addParam('_name', polygonType.name);
        editTask.addParam('_description', polygonType.description);
        //editTask.addParam('_is_publish', polygonType.isPublish);
        editTask.addParam('_style', polygonType.style);
        return editTask.execute();
    }

    /**
     * 更新离线区域类型
     */
    updateOfflinePolygonType(polygonType) {
        let editTask = new EditTask(EditType.OfflinePolygonType_Update);
        editTask.addParam('_id', polygonType.id);
        editTask.addParam('_name', polygonType.name);
        editTask.addParam('_description', polygonType.description);
        editTask.addParam('_style', polygonType.style);
        return editTask.execute();
    }

    /**
     * 删除离线区域类型
     */
    removeOfflinePolygonType(polygonType) {
        let editTask = new EditTask(EditType.OfflinePolygonType_Delete);
        editTask.addParam('_id', polygonType.id);
        return editTask.execute();
    }

    /**
     * 清空指定离线区域类型数据
     */
    removeOfflinePolygonsType(polygonType) {
        let editTask = new EditTask(EditType.OfflinePolygonsType_Delete);
        editTask.addParam('_id', polygonType.id);
        return editTask.execute();
    }

    //统计模块 20200706 yw
    /**
     * 查询点类型的要素总数
     * @param typeFactor
     * @returns {Promise<unknown>}
     */
    queryPointCount() {
        const query = new Query();
        query.setOrder({ id: 'desc' });
        const queryTask = new QueryTask(QueryType.StatsPointCount, false);
        return queryTask.execute(query);
    }

    /**
     * 查询线类型的要素总数
     * @param typeFactor
     * @returns {Promise<unknown>}
     */
    queryLineCount() {
        const query = new Query();
        query.setOrder({ id: 'desc' });
        const stats = new QueryTask(QueryType.StatsLineCount, false);
        return stats.execute(query);
    }

    /**
     * 查询区域类型的要素总数
     * @param typeFactor
     * @returns {Promise<unknown>}
     */
    queryFenceCount() {
        const query = new Query();
        query.setOrder({ id: 'desc' });
        const stats = new QueryTask(QueryType.StatsFenceCount, false);
        return stats.execute(query);
    }

    /**
     * 查询事件数量
     * @param event
     * @returns {Promise<unknown>}
     */
    queryEventCount() {
        const query = new Query();
        query.setOrder({ id: 'desc' });
        const stats = new QueryTask(QueryType.StatsEventCount, false);
        return stats.execute(query);
    }

    /**
     * 查询图标类型列表
     */
    queryIconTypeList() {
        let query = new Query();
        query.setPageSize(0);
        query.setOrder({ sort: 'asc', id: 'asc' });
        let queryTask = new QueryTask(QueryType.IconType, true);
        return queryTask.execute(query);
    }

    /**
     * 查询图标列表
     */
    queryIconList(filters) {
        let query = new Query();
        query.setPageSize(0);
        query.setOrder({ type: 'asc', sort: 'asc', name: 'asc', id: 'asc' });
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['field'], item['operator'], item['value'], item['type']);
            });
        }
        let queryTask = new QueryTask(QueryType.Icon, true);
        return queryTask.execute(query);
    }

    /**
     * 查询二维码
     * @param filters 必须包含_obj_id和_obj_type（1-组织；2-群组；3-成员类型），_pass_status：邀请通过状态（ 1-需要审核；2-直接通过，默认 ）
     * @param pageInfo
     * @returns {Promise<unknown>}
     */
    queryQRCodeList(filters, pageInfo) {
        let query = new Query();
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        query.addFilter('org_id', Operator.Equals, this.id);
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        query.setOrder({ create_time: 'desc' });
        let task = new QueryTask(QueryType.QRCodeList, pageInfo);
        return task.execute(query);
    }

    /**
     * 创建组织二维码邀请
     * @param invalidTime
     * @param remarks
     * @returns {Promise<unknown>}
     */
    createOrgQRCode(invalidTime, remarks) {
        let editTask = new EditTask(EditType.QRCode_Create);
        editTask.addParam('_obj_type', 1);
        editTask.addParam('_obj_id', this.id);
        editTask.addParam('_qr_exp_time', invalidTime);
        editTask.addParam('_qr_remark', remarks);
        editTask.addParam('_pass_status', 2);
        return editTask.execute();
    }

    /**
     * 创建群组二维码邀请
     * @param groupId 群组id
     * @param memberTypeId 成员类型id
     * @param invalidTime 失效时间
     * @param remarks 备注
     * @returns {Promise<unknown>}
     */
    createGroupQRCode(groupId, memberTypeId, invalidTime, remarks) {
        let editTask = new EditTask(EditType.QRCode_Create);
        editTask.addParam('_obj_type', 2);
        editTask.addParam('_obj_id', groupId);
        editTask.addParam('_qr_exp_time', invalidTime);
        editTask.addParam('_qr_remark', remarks);
        editTask.addParam('_pass_status', 2); //默认通过
        editTask.addParam('_rel_obj_type', 3);
        editTask.addParam('_rel_obj_id', memberTypeId);
        return editTask.execute();
    }

    /**
     * 成员类型二维码邀请
     * @param typeId
     * @param invalidTime
     * @param remarks
     * @returns {Promise | Promise<unknown>}
     */
    createMemberTypeQRCode(typeId, invalidTime, remarks) {
        let editTask = new EditTask(EditType.QRCode_Create);
        editTask.addParam('_obj_type', 3);
        editTask.addParam('_obj_id', typeId);
        editTask.addParam('_qr_exp_time', invalidTime);
        editTask.addParam('_qr_remark', remarks);
        editTask.addParam('_pass_status', 2); //默认通过
        return editTask.execute();
    }

    /**
     *
     * @param codeId 二维码id
     * @param invalidTime 失效时间
     * @param remarks 备注
     * @param refresh 是否刷新，默认false，(刷新:在源数据上修改，不是新建一条二维码数据)
     * @returns {Promise<unknown>}
     */
    updateQRCode(codeId, invalidTime, remarks, refresh = false) {
        let editTask = new EditTask(EditType.QRCode_Update);
        editTask.addParam('_qr_id', codeId);
        editTask.addParam('_qr_exp_time', invalidTime);
        editTask.addParam('_qr_remark', remarks);
        editTask.addParam('_qr_refresh', refresh); //不刷新
        editTask.addParam('_pass_status', 2);
        return editTask.execute();
    }

    /**
     * 批量更新二维码
     * @param params [{qr_id,exp_time,remark,refresh,pass_status},...,N]
     * @returns {Promise<unknown>}
     */
    updateBatchQRCode(params) {
        let editTask = new EditTask(EditType.QRCode_BatchUpdate);
        let arr = params.map((o) => {
            return {
                _qr_id: o['qr_id'],
                _qr_exp_time: o['exp_time'],
                _qr_remark: o['remark'],
                _qr_refresh: o['refresh'],
                _pass_status: o['pass_status'],
            };
        });
        editTask.addParam('_qr_codes', arr);
        return editTask.execute();
    }

    /**
     * 删除二维码
     * @param codeId
     * @returns {Promise<unknown>}
     */
    deleteQRCode(codeId) {
        let editTask = new EditTask(EditType.QRCode_Delete);
        editTask.addParam('_qr_id', codeId);
        return editTask.execute();
    }

    /**
     * banner类型数据
     * @returns {Promise<unknown>}
     */
    queryBannerTypeList() {
        let query = new Query();
        query.setOrder({ sort: 'asc' });
        let queryTask = new QueryTask(QueryType.BannerType, false);
        return queryTask.execute(query);
    }

    /**
     * 查询banner数据
     * @returns {Promise<unknown>}
     */
    queryBannerListByTypeId(typeId) {
        let query = new Query();
        query.addFilter('type', Operator.Equals, typeId);
        let queryTask = new QueryTask(QueryType.BannerList, false);
        return queryTask.execute(query);
    }

    /**
     * 查询设备历史数据 ps：参数必须包含macid和type(系统类型)
     * @param filters
     * @param pageInfo
     * @returns {Promise<unknown>}
     */
    queryEquipmentPointListById(filters, pageInfo) {
        let query = new Query();
        query.setType('mongodb');
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        // query.addFilter('dataType', Operator.NotEquals, 'null')
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryType = QueryMG.Equipment_Historical;
        if (this.unionStatus === 1) {
            //联合状态为父级组织
            queryType = QueryMG.Union_Equipment_Historical;
        }
        query.setOrder({ createTime: 'desc' });
        let queryTask = new QueryTask(queryType, pageInfo);
        return queryTask.execute(query);
    }

    /**
     * 系统集成token
     * 查询token列表
     * @param {*} params
     */
    connectToken(pageInfo, filters, order) {
        let query = new Query();
        query.addFilter('org_id', Operator.Equals, this.id);
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }

        let queryTask = new QueryTask(QueryType.CheckToken, pageInfo);
        return queryTask.execute(query);
    }

    /**
     * 更新token
     * @param {*} params
     */
    refreshToken(params) {
        let editTask = new EditTask(EditType.TokenEidt);
        editTask.addParam('_id', params.id);
        editTask.addParam('_jwt_expire', params.jwt_expire);
        editTask.addParam('_description', params.description);
        editTask.addParam('_name', params.name);
        editTask.addParam('_status', params.status);
        return editTask.execute();
        //
    }

    /**
     * 删除token
     * @param {*} params
     */
    clearToken(rowId) {
        // EditType.TokenDelete
        let editTask = new EditTask(EditType.TokenDelete);
        editTask.addParam('_id', rowId);
        return editTask.execute();
    }

    /**
     * 创建token
     * @param {*} params
     */
    creationToken(params) {
        // EditType.TokenCreate
        let editTask = new EditTask(EditType.TokenCreate);
        editTask.addParam('_jwt_expire', params.jwt_expire);
        editTask.addParam('_description', params.description);
        editTask.addParam('_name', params.name);
        editTask.addParam('_status', params.status);
        return editTask.execute();
    }

    /**
     *
     * 查询第三方列表
     * @returns
     */

    thirdpartyList(pageInfo) {
        let query = new Query();
        query.setOrder({ id: 'asc' });
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }

        let queryTask = new QueryTask(QueryType.ThirdpartyList, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /**
     * 新增类型关联API
     * @param
     */
    typeAddAPI(params) {
        let editTask = new EditTask(EditType.TypeAddAPI);
        editTask.addParam('_object_type', params.objectType);
        editTask.addParam('_api_is_publish', 1);
        editTask.addParam('_type_id', params.typeID);
        editTask.addParam('_api_name', params.api_name);
        editTask.addParam('_api_url', params.api_url);
        editTask.addParam('_api_description', params.description);
        return editTask.execute();
    }

    /**
     * 修改类型关联API
     * @param
     */
    typeUpdateAPI(params) {
        let editTask = new EditTask(EditType.TypeUpdateAPI);
        editTask.addParam('_api_is_publish', params.isPublish);
        editTask.addParam('_id', params.id);
        editTask.addParam('_api_name', params.apiName);
        editTask.addParam('_api_url', params.apiUrl);
        editTask.addParam('_api_description', params.description);
        return editTask.execute();
    }

    /**
     * 删除类型关联API
     * @param {*} params
     */
    typeDeleteAPI(params) {
        // EditType.TokenDelete
        let editTask = new EditTask(EditType.TypeDeleteAPI);
        editTask.addParam('_id', params);
        return editTask.execute();
    }

    /**
     *查询组织联合列表
     * @param {*} params
     */
    orgUnion(pageInfo, filters) {
        let query = new Query();

        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryTask = new QueryTask(QueryType.OrgUnion, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /**
     *查询组织联合记录列表
     * @param {*} params
     */
    UnionRecord(pageInfo, filters) {
        let query = new Query();
        query.setOrder({ create_time: 'desc' });

        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryTask = new QueryTask(QueryType.UnionRecord, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /**
     *查询组织联合记录详情列表
     * @param {*} params
     */
    unionRecordDetail(pageInfo, filters, order) {
        let query = new Query();

        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ datetime: 'desc' });
        }
        let queryTask = new QueryTask(QueryType.UnionRecordDetail, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /**
     *申请或邀请组织联合
     * @param {*} params
     */
    UnionInvite(params) {
        let editTask = new EditTask(EditType.UnionInvite);
        editTask.addParam('_union_way', params.unionWay);
        editTask.addParam('_abbreviation', params.abbreviation);
        editTask.addParam('_description', params.description);
        return editTask.execute();
    }

    /**
     *审核组织联合的邀请
     * @param {*} params
     * status:2 邀请通过 9 邀请被拒
     */
    UnionAudit(params) {
        let editTask = new EditTask(EditType.UnionAudit);
        editTask.addParam('_id', params.id);
        editTask.addParam('_status', params.status);
        editTask.addParam('_description', params.description);
        return editTask.execute();
    }

    /**
     *主动解除组织关联(退出)
     * @param {*} params
     *
     */
    UnionExit(params) {
        let editTask = new EditTask(EditType.UnionExit);
        // editTask.addParam('_children_org_id', params.id);
        editTask.addParam('_description', params.description);
        return editTask.execute();
    }

    /**
     *解除组织关联
     * @param {*} params
     *
     */
    UnionRemove(params) {
        let editTask = new EditTask(EditType.UnionRemove);
        editTask.addParam('_children_org_id', params.id);
        editTask.addParam('_description', params.description);
        return editTask.execute();
    }

    /**
     *取消组织联合的邀请
     * @param {*} params
     *
     */
    CloseUnionAudit(params) {
        let editTask = new EditTask(EditType.CloseUnionAudit);
        editTask.addParam('_id', params.id);
        return editTask.execute();
    }

    /**
     *查询组织列表
     * @param {*} params
     */
    orgList(pageInfo, filters) {
        let query = new Query();
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        let queryTask = new QueryTask(QueryType.orgList, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /**
     * 查询求救消息
     */
    sosRecord(pageInfo, filters, order) {
        let query = new Query();

        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ status: 'asc', datetime: 'desc' });
        }
        let queryTask = new QueryTask(QueryType.sosLecord, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /**处理求救 */
    sosStatusUpdate(params) {
        let editTask = new EditTask(EditType.sosStatusUpdate);
        editTask.addParam('_ids', params);
        return editTask.execute();
    }

    /*************
     * 查看通知
     */
    noticeMessageList(pageInfo, filters, order) {
        let query = new Query();

        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ create_time: 'desc' });
        }
        let queryTask = new QueryTask(QueryType.noticeMessage, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /* /!**
     * 发送通知
     *!/
    sendNotice(params) {
        return thirdpartyPost(SubmitType.sendNoticeMessage, params);
    }*/

    /****************
     * 查询协同数据审核列表

     */
    getSyneryData(pageInfo, filters, order) {
        let query = new Query();
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ id: 'desc' });
        }
        let queryTask = new QueryTask(QueryType.syneryData, pageInfo ? true : false);
        return queryTask.execute(query);
    }

    /**
     * 更新协同数据审核状态

     */
    updataSyneryData(params) {
        let editTask = new EditTask(EditType.synergyUpdata);
        editTask.addParam('_id', params.id);
        editTask.addParam('_status', params.status);
        editTask.addParam('_remark', params.remark);
        return editTask.execute();
    }

    /************************ MQTT *****************************/

    //订阅人员位置信息
    subscribeMemberLoc(params) {
        let param = Object.assign({}, params.object);
        if (!param.orgId) param.orgId = this.id;
        let MemberLocTopic = new CellsysPush.MemberLocTopic(param);
        let pushTask = new CellsysPush.pushTask();
        pushTask.subscribe({
            cellsysTopic: MemberLocTopic,
            onReceive: params.onReceive,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
        });
    }

    //取消订阅人员位置信息
    unSubscribeMemberLoc(params) {
        let param = Object.assign({}, params.object);
        if (!param.orgId) param.orgId = this.id;
        let MemberLocTopic = new CellsysPush.MemberLocTopic(param);
        let pushTask = new CellsysPush.pushTask();
        pushTask.unSubscribe({
            cellsysTopic: MemberLocTopic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
        });
    }

    //订阅设备信息
    subscribeEquipment(params) {
        let equipment = params.object,
            onSuccess = params.onSuccess,
            onFail = params.onFail,
            onReceive = params.onReceive;
        let equipmentLocTopic = new CellsysPush.EquipmentTopic(equipment);
        let pushTask = new CellsysPush.pushTask();
        pushTask.subscribe({
            cellsysTopic: equipmentLocTopic,
            onReceive: onReceive,
            onSuccess: onSuccess,
            onFail: onFail,
        });
    }

    /**
     * 发送消息
     * @param params
     */
    sendSysMessage(params) {
        let onSuccess = params.onSuccess,
            content = params.content,
            receiveIds = params.receivers;

        if (Array.isArray(receiveIds)) {
            //消息发送
            //let payload = `{"content":"${content}","receiveIds":[${receiveIds.join(',')}],"timestamp":${Date.now()}}`;

            //调整成使用标准json格式，再由JSON.stringify转成json字符串，否则则会出现特殊字符显示问题。
            let payload = {
                content: content,
                receiveIds: receiveIds,
                timestamp: Date.now(),
            };
            let topic = new CellsysPush.ChatSystemTopic(this.id);
            let pushTask = new CellsysPush.pushTask();
            pushTask.send({
                cellsysTopic: topic,
                message: JSON.stringify(payload),
            });
        }
    }

    //发送单聊消息topic
    sendSingleMessage(params) {
        let { content, conversationId, conversationName, senderId, senderName } = params;
        let singlePayload = {
            content: content,
            conversationId: conversationId,
            conversationName: conversationName,
            conversationType: 0,
            msgType: 0,
            senderId: senderId,
            senderName: senderName,
        };
        let topic = new CellsysPush.SingleChatTopic(this.id, conversationId, senderId);
        let pushTask = new CellsysPush.pushTask();
        pushTask.send({
            cellsysTopic: topic,
            message: JSON.stringify(singlePayload),
        });
    }

    //接收回复
    subscribeReplySysMessage(params) {
        let currentUser = params.currentUser;
        if (currentUser.isAdmin) {
            //只有管理员才会监听此话题
            let pushTask = new CellsysPush.pushTask();
            let receiveTopic = new CellsysPush.ChatSystemReplyTopic(this.id, params.receiver); //父组织
            pushTask.subscribe({
                cellsysTopic: receiveTopic,
                onSuccess: params.onSuccess,
                onFail: params.onFail,
                onReceive: params.onReceive,
            });

            let childrenReceiveTopics = [];
            if (this.unionStatus === 1) {
                //联合状态下同时订阅子组织聊天信息
                let unionOrgIds = this.unionOrgIds;
                if (unionOrgIds && unionOrgIds.length > 0) {
                    unionOrgIds.forEach((id) => {
                        childrenReceiveTopics.push(
                            new CellsysPush.ChatSystemReplyTopic(id, params.receiver),
                        );
                    });
                }
                childrenReceiveTopics.forEach((item) => {
                    pushTask.subscribe({
                        cellsysTopic: item,
                        onSuccess: params.onSuccess,
                        onFail: params.onFail,
                        onReceive: params.onReceive,
                    });
                });
            }
        }
        //单聊订阅
        let singleChartPushTask = new CellsysPush.pushTask();
        let singleChartTopic = new CellsysPush.SingleChatReplyTopic(
            this.id,
            params.currentUser.userId,
        ); //父组织
        singleChartPushTask.subscribe({
            cellsysTopic: singleChartTopic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });
    }

    /**
     * 订阅围栏事件
     * @param params
     */
    subscribeFenceEvent(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.FenceEventTopic(this.id);
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });
    }

    /**
     * 订阅SOS+求救
     */
    subscribeSOS(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.SosTopic({ orgId: this.id });
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });

        //组织联合模式下子组织消息订阅
        let childrenReceiveTopics = [];
        if (this.unionStatus === 1) {
            //联合状态下同时订阅子组织SOS
            let unionOrgIds = this.unionOrgIds;
            if (unionOrgIds && unionOrgIds.length > 0) {
                unionOrgIds.forEach((id) => {
                    childrenReceiveTopics.push(new CellsysPush.SosTopic({ orgId: id }));
                });
            }
            childrenReceiveTopics.forEach((item) => {
                pushTask.subscribe({
                    cellsysTopic: item,
                    onSuccess: params.onSuccess,
                    onFail: params.onFail,
                    onReceive: params.onReceive,
                });
            });
        }
    }

    /**
     * 北斗盒子订阅
     * @param params

     subscribeBDBox(params) {
     let pushTask = new CellsysPush.pushTask();
     let topic = new CellsysPush.BDBoxTopic({ orgId: this.id }, this);
     pushTask.subscribe({
     cellsysTopic: topic,
     onSuccess: params.onSuccess,
     onFail: params.onFail,
     onReceive: params.onReceive,
     });
     }*/

    /**
     * 订阅设备(监控组)
     */
    subscribeEquipmentMonitor(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.EquipmentMonitorTopic({
            orgId: this.id,
            topicName: params.topicName,
        });
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });
    }

    /**
     * 事件上传组织系统消息订阅
     * @param params
     */
    subscribeEventMessage(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.eventNoticeTopic(this.id);
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });

        //组织联合模式下子组织消息订阅
        let childrenReceiveTopics = [];
        if (this.unionStatus === 1) {
            //联合状态下同时订阅子组织SOS
            let unionOrgIds = this.unionOrgIds;
            if (unionOrgIds && unionOrgIds.length > 0) {
                unionOrgIds.forEach((id) => {
                    childrenReceiveTopics.push(new CellsysPush.eventNoticeTopic(id));
                });
            }
            childrenReceiveTopics.forEach((item) => {
                pushTask.subscribe({
                    cellsysTopic: item,
                    onSuccess: params.onSuccess,
                    onFail: params.onFail,
                    onReceive: params.onReceive,
                });
            });
        }
    }

    /**
     * 标记上传组织系统消息订阅
     * @param params
     */
    subscribeMarkerMessage(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.markerNoticeTopic(this.id);
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });

        //组织联合模式下子组织消息订阅
        let childrenReceiveTopics = [];
        if (this.unionStatus === 1) {
            //联合状态下同时订阅子组织SOS
            let unionOrgIds = this.unionOrgIds;
            if (unionOrgIds && unionOrgIds.length > 0) {
                unionOrgIds.forEach((id) => {
                    childrenReceiveTopics.push(new CellsysPush.markerNoticeTopic(id));
                });
            }
            childrenReceiveTopics.forEach((item) => {
                pushTask.subscribe({
                    cellsysTopic: item,
                    onSuccess: params.onSuccess,
                    onFail: params.onFail,
                    onReceive: params.onReceive,
                });
            });
        }
    }

    //监听设备状态
    subscribeEquipmentStatus(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.EquipmentStatusTopic(this.id);
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });

        //组织联合模式下子组织消息订阅
        let childrenReceiveTopics = [];
        if (this.unionStatus === 1) {
            //联合状态下同时订阅子组织SOS
            let unionOrgIds = this.unionOrgIds;
            if (unionOrgIds && unionOrgIds.length > 0) {
                unionOrgIds.forEach((id) => {
                    childrenReceiveTopics.push(new CellsysPush.EquipmentStatusTopic(id));
                });
            }
            childrenReceiveTopics.forEach((item) => {
                pushTask.subscribe({
                    cellsysTopic: item,
                    onSuccess: params.onSuccess,
                    onFail: params.onFail,
                    onReceive: params.onReceive,
                });
            });
        }
    }

    //监听edgeCommonder消息
    subscribeEdgeCommander(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.EquToEdgeTopic(this.id, params.macId);
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });
    }

    //监听cellsys系统消息，如成员加入组织申请
    subscribeMemberJoin(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.memberJoinTopic(this.id);
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });
    }

    //管理员批量更新协同数据发布状态
    updateSynergyDatasPublish(dataList, type) {
        let editTask = new EditTask(EditType.SynergyDatasPublishUpdate);
        let datas = null;
        if (dataList && dataList.length > 0) {
            datas = dataList.map((item) => {
                let { id, isPublish, dataName, remark } = item;
                return {
                    _id: id,
                    _is_publish: isPublish,
                    _data_name: dataName,
                    _remark: remark,
                };
            });
        }
        if (datas) {
            editTask.addParam('_synergy_datas', datas);
        }
        editTask.addParam('_synergy_data_type', type);
        return editTask.execute();
    }

    //查询标签
    queryTags(queryParams) {
        if (!queryParams) {
            queryParams = {
                pageInfo: {
                    currPage: 1,
                    pageSize: 0,
                },
            };
        }
        let { pageInfo, filters, order } = queryParams;
        let query = new Query();
        if (pageInfo) {
            query.setCurrPage(pageInfo.currPage);
            query.setPageSize(pageInfo.pageSize);
        }
        if (filters && filters.length > 0) {
            filters.forEach((item) => {
                query.addFilter(item['name'], item['operator'], item['value']);
            });
        }
        if (order) {
            query.setOrder(order);
        } else {
            query.setOrder({ create_time: 'desc' });
        }
        let queryTask = new QueryTask(QueryType.Tag, pageInfo ? true : false);
        return new Promise((resolve, reject) => {
            queryTask
                .execute(query)
                .then((res) => {
                    if (pageInfo) {
                        if (res.data) {
                            res.data = res.data.map((item) => {
                                return new CellsysTag(item);
                            });
                            resolve(res);
                        }
                    } else {
                        let resArr = res.map((item) => {
                            return new CellsysTag(item);
                        });
                        resolve(resArr);
                    }
                })
                .catch((err) => {
                    reject(err);
                });
        });
    }

    //创建标签组
    createTagGroup(tagTypeParams) {
        let editTask = new EditTask(EditType.TagGroup_Insert);
        editTask.addParam('_name', tagTypeParams.name);
        editTask.addParam('_description', tagTypeParams.description);
        return editTask.execute();
    }

    //创建标签
    createTag(tagParams) {
        let editTask = new EditTask(EditType.Tag_Insert);
        editTask.addParam('_name', tagParams.name);
        editTask.addParam('_description', tagParams.description);
        if (tagParams.tagGroupName) {
            editTask.addParam('_tag_group_name', tagParams.tagGroupName);
        }
        return editTask.execute();
    }

    //批量创建标签
    createTags(tags) {
        let editTask = new EditTask(EditType.Tags_Insert);
        let _tags = tags.map((item) => {
            let param = {
                _name: item.name,
                _description: item.description,
            };
            if (item.tagGroupName) {
                param['_tag_group_name'] = item.tagGroupName;
            }
            return param;
        });
        editTask.addParam('_tags', _tags);
        return editTask.execute();
    }

    //更新标签
    updateTag(tag) {
        let editTask = new EditTask(EditType.Tag_Update);
        editTask.addParam('_id', tag.id);
        editTask.addParam('_name', tag.name);
        editTask.addParam('_description', tag.description);
        return editTask.execute();
    }

    //删除标签
    deleteTag(tag) {
        let editTask = new EditTask(EditType.Tag_Delete);
        editTask.addParam('_id', tag.id);
        return editTask.execute();
    }

    updateTagRel(relParams) {
        let { tags, modelCode, modelObjectId } = relParams;
        //if (!Array.isArray(modelObjectIds)) {
        //    throw new Error("参数错误，modelObjectIds应该为数组")
        //}
        let editTask = new EditTask(EditType.TagsGroupModeleUpdate);
        if (Array.isArray(tags)) {
            let tagNames = tags.map((tag) => {
                return tag.name;
            });
            editTask.addParam('_tag_names', tagNames);
        }
        editTask.addParam('_model_code', modelCode);
        editTask.addParam('_model_object_id', modelObjectId);
        return editTask.execute();
    }

    //修改标签与模块组的关联
    updateTagModeleGroup(params) {
        if (!Array.isArray(params.modelObjectIds)) {
            throw new Error('参数错误，modelObjectIds应该为数组');
        }
        let editTask = new EditTask(EditType.TagModeleGroupUpdate);
        editTask.addParam('_tag_name', params.tagName);
        editTask.addParam('_model_code', params.modelCode);
        editTask.addParam('_model_object_ids', params.modelObjectIds);
        return editTask.execute();
    }

    //发送成员审核结果通知
    sendMemberAuditMessage(params) {
        let { status, userId } = params;
        let payload = {
            status: status,
            orgName: this.name,
            abbreviation: this.abbreviation,
            timeStamp: new Date().getTime(),
        };
        let topic = new CellsysPush.memberAuditTopic(this.id, userId);
        let pushTask = new CellsysPush.pushTask();
        pushTask.send({
            cellsysTopic: topic,
            message: JSON.stringify(payload),
        });
    }

    //发送离线地图生成状态
    sendOfflineFenceState(params) {
        let pushTask = new CellsysPush.pushTask();
        let topic = new CellsysPush.offlineFenceTopic(this.id);
        pushTask.subscribe({
            cellsysTopic: topic,
            onSuccess: params.onSuccess,
            onFail: params.onFail,
            onReceive: params.onReceive,
        });
    }
}

export default CellsysOrg;