组织切换组织树优化替换

20c05fcc · wk · 6199a14c · 20c05fcc · 20c05fcc · 20c05fcc
--- a/common/config.js
+++ b/common/config.js
@@ -3,16 +3,16 @@ const $config = {
 	loginTemplateNo: "industry-0001",
 	systemCode: "buildingSite",
 	/* 授权码 */
-	// authCode: "477A0661-EF04-11F7-9D69-0BDD73F06500",
+	authCode: "477A0661-EF04-11F7-9D69-0BDD73F06500",
 	// authCode: "07EC0FDA-0249-6DB3-7422-0AFFF34E0E90", //测试
-	authCode: "D0539533-E169-5338-8ED7-3FAD554F4F62", //正式
+	// authCode: "D0539533-E169-5338-8ED7-3FAD554F4F62", //正式
 	pageSize: 20,
 	isPage: 1,
 	smsCfg: "industry",
 	/* api域名 */
-	// base: "https://dev-console-api.hzdingmao.com",
+	base: "https://dev-console-api.hzdingmao.com",
 	// base: "https://test-console-api.hzdingmao.com",
-	base: "https://console-api.hibuilding.cn",
+	// base: "https://console-api.hibuilding.cn",
 	/* 工地沟通日 */
 	// gtrBase:"https://cwcd-h5.huizhucloud.com",//测试
 	gtrBase: "https://gdt-front-mobile.hibuilding.cn", //生产

--- a/components/ly-tree-nvue/ly-tree-node.vue
+++ b/components/ly-tree-nvue/ly-tree-node.vue
@@ -321,8 +321,8 @@
 	}
 	.ly-tree-node__icon {
-		width: 30rpx;
+		width: 40rpx;
-		height: 30rpx;
+		height: 40rpx;
 		overflow: hidden;
 		margin-right: 16rpx;
 	}
@@ -334,8 +334,8 @@
 	}
 	.ly-tree-node__label {
-		font-size: 32rpx;
+		font-size: 28rpx;
-		color: #333333;
+		color: #606266;
 		width: 750rpx;
 	}

--- a/components/ly-tree/ly-tree.vue
+++ b/components/ly-tree/ly-tree.vue
@@ -5,16 +5,26 @@
 				<view class="ly-loader-inner">加载中...</view>
 			</view>
 		</template>
 		<template v-else>
-			<view v-if="isEmpty || !visible" class="ly-empty">
+			<view v-if="isEmpty || !visible" 
+				class="ly-empty">
 				{{emptyText}}
 			</view>
-			<view :key="updateKey" class="ly-tree" :class="{'is-empty': isEmpty || !visible}" role="tree"
+			<view :key="updateKey"
+				class="ly-tree" 
+				:class="{'is-empty': isEmpty || !visible}" 
+				role="tree" 
 				name="LyTreeExpand">
-				<ly-tree-node v-for="nodeId in childNodesId" :nodeId="nodeId" :render-after-expand="renderAfterExpand"
+				<ly-tree-node v-for="nodeId in childNodesId" 
-					:show-checkbox="showCheckbox" :show-radio="showRadio" :check-only-leaf="checkOnlyLeaf"
+					:nodeId="nodeId" 
-					:key="getNodeKey(nodeId)" :indent="indent" :icon-class="iconClass">
+					:render-after-expand="renderAfterExpand"
+					:show-checkbox="showCheckbox" 
+					:show-radio="showRadio" 
+					:check-only-leaf="checkOnlyLeaf"
+					:key="getNodeKey(nodeId)" 
+					:indent="indent" 
+					:icon-class="iconClass">
 				</ly-tree-node>
 			</view>
 		</template>
@@ -24,20 +34,18 @@
 <script>
 	import Vue from 'vue'
 	import TreeStore from './model/tree-store.js';
-	import {
+	import {getNodeKey} from './tool/util.js';
-		getNodeKey
-	} from './tool/util.js';
 	import LyTreeNode from './ly-tree-node.vue';
 	export default {
 		name: 'LyTree',
 		componentName: 'LyTree',
 		components: {
 			LyTreeNode
 		},
 		data() {
 			return {
 				updateKey: new Date().getTime(), // 数据更新的时候，重新渲染树
@@ -50,102 +58,102 @@
 				childNodesId: []
 			};
 		},
 		provide() {
-			return {
+		    return {
-				tree: this
+		       tree: this
-			}
+		    }
 		},
 		props: {
 			// 展示数据
 			treeData: Array,
 			// 自主控制loading加载，避免数据还没获取到的空档出现“暂无数据”字样
 			ready: {
 				type: Boolean,
 				default: true
 			},
 			// 内容为空的时候展示的文本
 			emptyText: {
 				type: String,
 				default: '暂无数据'
 			},
 			// 是否在第一次展开某个树节点后才渲染其子节点
 			renderAfterExpand: {
 				type: Boolean,
 				default: true
 			},
 			// 每个树节点用来作为唯一标识的属性，整棵树应该是唯一的
 			nodeKey: String,
 			// 在显示复选框的情况下，是否严格的遵循父子不互相关联的做法，默认为 false
 			checkStrictly: Boolean,
 			// 是否默认展开所有节点
 			defaultExpandAll: Boolean,
 			// 切换全部展开、全部折叠
 			toggleExpendAll: Boolean,
 			// 是否在点击节点的时候展开或者收缩节点， 默认值为 true，如果为 false，则只有点箭头图标的时候才会展开或者收缩节点
 			expandOnClickNode: {
 				type: Boolean,
 				default: true
 			},
 			// 选中的时候展开节点
 			expandOnCheckNode: {
 				type: Boolean,
 				default: true
 			},
 			// 是否在点击节点的时候选中节点，默认值为 false，即只有在点击复选框时才会选中节点
 			checkOnClickNode: Boolean,
 			checkDescendants: {
 				type: Boolean,
 				default: false
 			},
 			// 展开子节点的时候是否自动展开父节点
 			autoExpandParent: {
 				type: Boolean,
 				default: true
 			},
 			// 默认勾选的节点的 key 的数组
 			defaultCheckedKeys: Array,
 			// 默认展开的节点的 key 的数组
 			defaultExpandedKeys: Array,
 			// 是否展开当前节点的父节点
 			expandCurrentNodeParent: Boolean,
 			// 当前选中的节点
 			currentNodeKey: [String, Number],
 			// 是否最后一层叶子节点才显示单选/多选框
 			checkOnlyLeaf: {
 				type: Boolean,
 				default: false
 			},
 			// 节点是否可被选择
 			showCheckbox: {
 				type: Boolean,
 				default: false
 			},
 			// 节点单选
 			showRadio: {
 				type: Boolean,
 				default: false
 			},
 			// 配置选项
 			props: {
 				type: [Object, Function],
@@ -157,76 +165,74 @@
 					};
 				}
 			},
 			// 是否懒加载子节点，需与 load 方法结合使用
 			lazy: {
 				type: Boolean,
 				default: false
 			},
 			// 是否高亮当前选中节点，默认值是 false
 			highlightCurrent: Boolean,
 			// 加载子树数据的方法，仅当 lazy 属性为true 时生效
 			load: Function,
 			// 对树节点进行筛选时执行的方法，返回 true 表示这个节点可以显示，返回 false 则表示这个节点会被隐藏
 			filterNodeMethod: Function,
 			// 搜索时是否展示匹配项的所有子节点
 			childVisibleForFilterNode: {
 				type: Boolean,
 				default: false
 			},
 			// 是否每次只打开一个同级树节点展开
 			accordion: Boolean,
 			// 相邻级节点间的水平缩进，单位为像素
 			indent: {
 				type: Number,
 				default: 18
 			},
 			// 自定义树节点的展开图标
 			iconClass: String,
 			// 是否显示节点图标，如果配置为true,需要配置props中对应的图标属性名称
 			showNodeIcon: {
 				type: Boolean,
 				default: false
 			},
 			// 当节点图标显示出错时，显示的默认图标
 			defaultNodeIcon: {
 				type: String,
 				default: 'https://img-cdn-qiniu.dcloud.net.cn/uniapp/doc/github.svg'
 			},
 			// 如果数据量较大，建议不要在node节点中添加parent属性，会造成性能损耗
 			isInjectParentInNode: {
 				type: Boolean,
 				default: false
 			}
 		},
 		computed: {
 			isEmpty() {
 				if (this.store.root) {
 					const childNodes = this.store.root.getChildNodes(this.childNodesId);
-					return !childNodes || childNodes.length === 0 || childNodes.every(({
+					return !childNodes || childNodes.length === 0 || childNodes.every(({visible}) => !visible);
-						visible
-					}) => !visible);
 				}
 				return true;
 			},
 			showLoading() {
 				return !(this.store.ready && this.ready);
 			}
 		},
 		watch: {
 			toggleExpendAll(newVal) {
 				this.store.toggleExpendAll(newVal);
@@ -247,7 +253,7 @@
 			'store.root.visible'(newVal) {
 				this.visible = newVal;
 			},
-			childNodesId() {
+			childNodesId(){
 				this.$nextTick(() => {
 					this.$emit('ly-tree-render-completed');
 				});
@@ -260,233 +266,232 @@
 				deep: true
 			}
 		},
 		methods: {
 			/*
 			 * @description 对树节点进行筛选操作
 			 * @method filter
 			 * @param {all} value 在 filter-node-method 中作为第一个参数
 			 * @param {Object} data 搜索指定节点的节点数据，不传代表搜索所有节点，假如要搜索A节点下面的数据，那么nodeData代表treeData中A节点的数据
-			 */
+			*/
 			filter(value, data) {
 				if (!this.filterNodeMethod) throw new Error('[Tree] filterNodeMethod is required when filter');
 				this.store.filter(value, data);
 			},
 			/*
 			 * @description 获取节点的唯一标识符
 			 * @method getNodeKey
 			 * @param {String, Number} nodeId
 			 * @return {String, Number} 匹配到的数据中的某一项数据
-			 */
+			*/
 			getNodeKey(nodeId) {
 				let node = this.store.root.getChildNodes([nodeId])[0];
 				return getNodeKey(this.nodeKey, node.data);
 			},
-			/*
+		   /*
-			 * @description 获取节点路径
+		    * @description 获取节点路径
-			 * @method getNodePath
+		    * @method getNodePath
-			 * @param {Object} data 节点数据
+		    * @param {Object} data 节点数据
-			 * @return {Array} 路径数组
+		    * @return {Array} 路径数组
-			 */
+		   */
 			getNodePath(data) {
 				return this.store.getNodePath(data);
 			},
 			/*
 			 * @description 若节点可被选择（即 show-checkbox 为 true），则返回目前被选中的节点所组成的数组
 			 * @method getCheckedNodes
 			 * @param {Boolean} leafOnly 是否只是叶子节点，默认false
 			 * @param {Boolean} includeHalfChecked 是否包含半选节点，默认false
 			 * @return {Array} 目前被选中的节点所组成的数组
-			 */
+			*/
 			getCheckedNodes(leafOnly, includeHalfChecked) {
 				return this.store.getCheckedNodes(leafOnly, includeHalfChecked);
 			},
 			/*
 			 * @description 若节点可被选择（即 show-checkbox 为 true），则返回目前被选中的节点的 key 所组成的数组
 			 * @method getCheckedKeys
 			 * @param {Boolean} leafOnly 是否只是叶子节点，默认false,若为 true 则仅返回被选中的叶子节点的 keys
 			 * @param {Boolean} includeHalfChecked 是否返回indeterminate为true的节点，默认false
 			 * @return {Array} 目前被选中的节点所组成的数组
-			 */
+			*/
 			getCheckedKeys(leafOnly, includeHalfChecked) {
 				return this.store.getCheckedKeys(leafOnly, includeHalfChecked);
 			},
 			/*
 			 * @description 获取当前被选中节点的 data，若没有节点被选中则返回 null
 			 * @method getCurrentNode
 			 * @return {Object} 当前被选中节点的 data，若没有节点被选中则返回 null
-			 */
+			*/
 			getCurrentNode() {
 				const currentNode = this.store.getCurrentNode();
 				return currentNode ? currentNode.data : null;
 			},
 			/*
 			 * @description 获取当前被选中节点的 key，若没有节点被选中则返回 null
 			 * @method getCurrentKey
 			 * @return {all} 当前被选中节点的 key， 若没有节点被选中则返回 null
-			 */
+			*/
 			getCurrentKey() {
 				const currentNode = this.getCurrentNode();
 				return currentNode ? currentNode[this.nodeKey] : null;
 			},
 			/*
 			 * @description 设置全选/取消全选
 			 * @method setCheckAll
 			 * @param {Boolean} isCheckAll 选中状态,默认为true
-			 */
+			*/
 			setCheckAll(isCheckAll = true) {
 				if (this.showRadio) throw new Error('You set the "show-radio" property, so you cannot select all nodes');
-				if (!this.showCheckbox) console.warn(
+				if (!this.showCheckbox) console.warn('You have not set the property "show-checkbox". Please check your settings');
-					'You have not set the property "show-checkbox". Please check your settings');
 				this.store.setCheckAll(isCheckAll);
 			},
 			/*
 			 * @description 设置目前勾选的节点
 			 * @method setCheckedNodes
 			 * @param {Array} nodes 接收勾选节点数据的数组
 			 * @param {Boolean} leafOnly 是否只是叶子节点, 若为 true 则仅设置叶子节点的选中状态，默认值为 false
-			 */
+			*/
 			setCheckedNodes(nodes, leafOnly) {
 				this.store.setCheckedNodes(nodes, leafOnly);
 			},
 			/*
 			 * @description 通过 keys 设置目前勾选的节点
 			 * @method setCheckedKeys
 			 * @param {Array} keys 勾选节点的 key 的数组 
 			 * @param {Boolean} leafOnly 是否只是叶子节点, 若为 true 则仅设置叶子节点的选中状态，默认值为 false
-			 */
+			*/
 			setCheckedKeys(keys, leafOnly) {
 				if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCheckedKeys');
 				this.store.setCheckedKeys(keys, leafOnly);
 			},
 			/*
 			 * @description 通过 key / data 设置某个节点的勾选状态
 			 * @method setChecked
 			 * @param {all} data 勾选节点的 key 或者 data 
 			 * @param {Boolean} checked 节点是否选中
 			 * @param {Boolean} deep 是否设置子节点 ，默认为 false
-			 */
+			*/
 			setChecked(data, checked, deep) {
 				this.store.setChecked(data, checked, deep);
 			},
 			/*
 			 * @description 若节点可被选择（即 show-checkbox 为 true），则返回目前半选中的节点所组成的数组
 			 * @method getHalfCheckedNodes
 			 * @return {Array} 目前半选中的节点所组成的数组
-			 */
+			*/
 			getHalfCheckedNodes() {
 				return this.store.getHalfCheckedNodes();
 			},
 			/*
 			 * @description 若节点可被选择（即 show-checkbox 为 true），则返回目前半选中的节点的 key 所组成的数组
 			 * @method getHalfCheckedKeys
 			 * @return {Array} 目前半选中的节点的 key 所组成的数组
-			 */
+			*/
 			getHalfCheckedKeys() {
 				return this.store.getHalfCheckedKeys();
 			},
 			/*
 			 * @description 通过 node 设置某个节点的当前选中状态
 			 * @method setCurrentNode
 			 * @param {Object} node 待被选节点的 node
-			 */
+			*/
 			setCurrentNode(node) {
 				if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCurrentNode');
 				this.store.setUserCurrentNode(node);
 			},
 			/*
 			 * @description 通过 key 设置某个节点的当前选中状态
 			 * @method setCurrentKey
 			 * @param {all} key 待被选节点的 key，若为 null 则取消当前高亮的节点
-			 */
+			*/
 			setCurrentKey(key) {
 				if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCurrentKey');
 				this.store.setCurrentNodeKey(key);
 			},
 			/*
 			 * @description 根据 data 或者 key 拿到 Tree 组件中的 node
 			 * @method getNode
 			 * @param {all} data 要获得 node 的 key 或者 data
-			 */
+			*/
 			getNode(data) {
 				return this.store.getNode(data);
 			},
 			/*
 			 * @description 删除 Tree 中的一个节点
 			 * @method remove
 			 * @param {all} data 要删除的节点的 data 或者 node
-			 */
+			*/
 			remove(data) {
 				this.store.remove(data);
 			},
 			/*
 			 * @description 为 Tree 中的一个节点追加一个子节点
 			 * @method append
 			 * @param {Object} data 要追加的子节点的 data 
 			 * @param {Object} parentNode 子节点的 parent 的 data、key 或者 node
-			 */
+			*/
 			append(data, parentNode) {
 				this.store.append(data, parentNode);
 			},
 			/*
 			 * @description 为 Tree 的一个节点的前面增加一个节点
 			 * @method insertBefore
 			 * @param {Object} data 要增加的节点的 data 
 			 * @param {all} refNode 要增加的节点的后一个节点的 data、key 或者 node
-			 */
+			*/
 			insertBefore(data, refNode) {
 				this.store.insertBefore(data, refNode);
 			},
 			/*
 			 * @description 为 Tree 的一个节点的后面增加一个节点
 			 * @method insertAfter
 			 * @param {Object} data 要增加的节点的 data 
 			 * @param {all} refNode 要增加的节点的前一个节点的 data、key 或者 node
-			 */
+			*/
 			insertAfter(data, refNode) {
 				this.store.insertAfter(data, refNode);
 			},
 			/*
 			 * @description 通过 keys 设置节点子元素
 			 * @method updateKeyChildren
 			 * @param {String, Number} key 节点 key 
 			 * @param {Object} data 节点数据的数组
-			 */
+			*/
 			updateKeyChildren(key, data) {
 				if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in updateKeyChild');
 				this.store.updateChildren(key, data);
 			}
 		},
 		created() {
 			this.isTree = true;
 			let props = this.props;
 			if (typeof this.props === 'function') props = this.props();
 			if (typeof props !== 'object') throw new Error('props must be of object type.');
 			this.store = new TreeStore({
 				key: this.nodeKey,
 				data: this.treeData,
@@ -512,7 +517,7 @@
 			this.childNodesId = this.store.root.childNodesId;
 		},
 		beforeDestroy() {
 			if (this.accordion) {
 				uni.$off(`${this.elId}-tree-node-expand`)
@@ -526,14 +531,14 @@
 		position: relative;
 		cursor: default;
 		background: #FFF;
-		color: #333333;
+		color: #606266;
-		padding: 20rpx;
+		padding: 30rpx;
 	}
 	.ly-tree.is-empty {
 		background: transparent;
 	}
 	/* lyEmpty-start */
 	.ly-empty {
 		width: 100%;
@@ -541,9 +546,8 @@
 		justify-content: center;
 		margin-top: 100rpx;
 	}
 	/* lyEmpty-end */
 	/* lyLoader-start */
 	.ly-loader {
 		margin-top: 100rpx;
@@ -551,7 +555,7 @@
 		align-items: center;
 		justify-content: center;
 	}
 	.ly-loader-inner,
 	.ly-loader-inner:before,
 	.ly-loader-inner:after {
@@ -560,41 +564,39 @@
 		width: .5em;
 		height: 1em;
 	}
 	.ly-loader-inner:before,
 	.ly-loader-inner:after {
 		position: absolute;
 		top: 0;
 		content: '';
 	}
 	.ly-loader-inner:before {
 		left: -1em;
 	}
 	.ly-loader-inner {
 		text-indent: -9999em;
 		position: relative;
 		font-size: 22rpx;
 		animation-delay: 0.16s;
 	}
 	.ly-loader-inner:after {
 		left: 1em;
 		animation-delay: 0.32s;
 	}
 	/* lyLoader-end */
 	@keyframes load {
 		0%,
 		80%,
 		100% {
 			box-shadow: 0 0 #efefef;
 			height: 1em;
 		}
 		40% {
 			box-shadow: 0 -1.5em #efefef;
 			height: 1.5em;

--- a/components/uni-tabbar/uni-tabbar.vue
+++ b/components/uni-tabbar/uni-tabbar.vue
@@ -109,7 +109,7 @@
 				uni.scanCode({
 					success(res) {
 						let result = res.result
-						if (result.indexOf("?") != -1) {
+						if (result.indexOf("?") != -1) { //一物一码
 							let param = result.split("?")[1]
 							let params = param.replace(/&/g, '","').replace(/=/g, '":"')
 							let paramJson = `{"${params}"}`
@@ -129,7 +129,8 @@
 								})
 							}
 						} else {
-							that.$toast.showToast("二维码格式不正确")
+							that.orgCode(res)
+							// that.$toast.showToast("二维码格式不正确")
 						}
 					},
 					fail() {
@@ -137,6 +138,36 @@
 					}
 				})
 			},
+			orgCode(res) {
+				try {
+					let result = JSON.parse(res.result)
+					if (result && typeof result == 'object') {
+						let type = result.type
+						if (type == "company") {
+							this.code = result.text
+							uni.navigateTo({
+								url: `/pages/login/joinDepartment/joinDepartment?code=${this.code}&type=company`
+							})
+						} else if (type == "project") {
+							this.code = result.text
+							uni.navigateTo({
+								url: `/pages/login/joinDepartment/joinDepartment?code=${this.code}&type=project&projectId=${result.ext.id}`
+							})
+						} else if (type == "department") {
+							this.code = result.text
+							uni.navigateTo({
+								url: `/pages/login/joinDepartment/joinDepartment?code=${this.code}&type=department`
+							})
+						} else {
+							this.$toast.showToast("二维码格式不正确")
+						}
+					} else {
+						this.$toast.showToast("二维码格式不正确")
+					}
+				} catch (e) {
+					this.$toast.showToast("二维码格式不正确")
+				}
+			}
 		}
 	}
 </script>

--- a/pages.json
+++ b/pages.json
@@ -473,7 +473,10 @@
 		"navigationBarTextStyle": "white",
 		"navigationBarTitleText": "智慧工地一点通",
 		"navigationBarBackgroundColor": "#3B73FE",
-		"backgroundColor": "#3B73FE"
+		"backgroundColor": "#3B73FE",
+		"usingComponents": {
+			"ly-tree-node": "/components/ly-tree/ly-tree-node"
+		}
 	},
 	"uniIdRouter": {},
 	"tabBar": {

--- a/pages/gallery/gallery.vue
+++ b/pages/gallery/gallery.vue
@@ -189,7 +189,7 @@
 					return
 				}
 				uni.navigateTo({
-					url: "/pages/mine/changeOrg/changeOrg"
+					url: "/pagesSub/mine/changeOrg/changeOrg"
 				})
 			},
 			toIndex(model) {

--- a/pages/index/index.vue
+++ b/pages/index/index.vue
@@ -568,21 +568,17 @@
 						//如果是工人  获取工人当前项目
 						if (this.role == 'PM') {
 							if (jobs) {
+								let currentJob = jobs[0]
+								uni.setStorageSync("org_no", currentJob.org_no)
+								uni.setStorageSync("org_id", currentJob.org_id)
 								//当前岗位  判断当前岗位是项目部还是其他
 								if (this.userInfo.user.dept_type == '2') { //项目级
-									this.project_id = uni.getStorageSync("project_id")
+									uni.setStorageSync("org_name", currentJob.dept_name)
-									console.log("当前组织", this.project_id);
-									if (!this.project_id) {
-										this.loadProject()
-									} else {
-										this.initData()
-									}
 								} else {
-									let currentJob = jobs[0]
-									uni.setStorageSync("org_no", currentJob.org_no)
 									uni.setStorageSync("org_name", currentJob.org_name)
 									this.initData()
 								}
+								this.initData()
 							}
 						} else {
 							this.project_id = uni.getStorageSync("project_id")

--- a/pagesSub/mine/changeCompany/changeCompany.vue
+++ b/pagesSub/mine/changeCompany/changeCompany.vue
@@ -11,8 +11,9 @@
 						<view class="enter">{{isCurrent(item)?"当前组织":""}}</view>
 					</view>
 					<view class="job-content" v-if="item.isOpen">
-						<view class="j-item" v-for="(job,jIndex) in item.job_list" :key="jIndex">
+						<view class="j-item" v-for="(job,jIndex) in item.job_list" :key="jIndex"
-							<view class="j-name" @click="jobSel(item,job)">
+							@click="jobSel(item,job)">
+							<view class="j-name">
 								{{job.dept_name}}-{{job.job_name}}
 							</view>
 							<image :src="setSelImage(job)" class="image"></image>
@@ -221,6 +222,7 @@
 			.job-content {
 				display: flex;
 				flex-direction: column;
+				margin-left: 40rpx;
 				.j-item {
 					padding: 30rpx 30rpx 0 30rpx;

--- a/pagesSub/mine/changeOrg/changeOrg.vue
+++ b/pagesSub/mine/changeOrg/changeOrg.vue
@@ -4,16 +4,25 @@
 		<view class="search">
 			<view class="search-content">
 				<image src="../../../static/ic-search.png" class="image"></image>
-				<input placeholder="搜索" placeholder-class="placeholderStyle" @input="search" class="inputStyle" />
+				<input placeholder="搜索" placeholder-class="placeholderStyle" @input="search" class="inputStyle"
+					v-model="key" />
 			</view>
 		</view>
-		<view class="org-content">
+		<ly-tree :tree-data="trees" :props="treeProps" node-key="id" @node-expand="handleNodeExpand"
+			@node-click="handleNodeClick" :showRadio="true" ref="tree" :defaultCheckedKeys="currentKeys"
+			:defaultExpandedKeys="currentKeys" childVisibleForFilterNode="true" :filter-node-method="filterNode"
+			:checkOnClickNode="true" :childVisibleForFilterNode="true">
+		</ly-tree>
+		<view class="uni-group-button">
+			<view class="uni-blue-button" @click="toSwitch">确认切换该组织</view>
+		</view>
+		<!-- 暂时处理 -->
+		<view class="org-content" v-if="false">
 			<view class="org-list">
 				<view class="org-item" v-for="(tree,index) in trees" :key="index">
 					<view class="org">
-						<image
+						<image v-if="isImgShow(tree)" :src="setImgSrc(tree)" class="image"
-							:src="tree.isOpen?'../../../static/icon_up_arrow.png':'../../../static/icon_drop_arrow.png'"
+							@click="toNextLevel(tree,index)">
-							class="image" @click="toNextLevel(tree,index)">
 						</image>
 						<view class="name" @click="toNextLevel(tree,index)">{{tree.name}}</view>
 						<view class=" enter" @click="itemClick(tree)">进入</view>
@@ -21,10 +30,8 @@
 					<view v-if="tree.isOpen" style="margin-top: 20rpx;">
 						<view class="org-item" v-for="(oneLevel,oneIndex) in tree.children_list" :key="oneIndex">
 							<view class="org">
-								<image
+								<image v-if="isImgShow(oneLevel)" :src="setImgSrc(oneLevel)" class="image"
-									v-if="!oneLevel.project_id&&oneLevel.children_list&&oneLevel.children_list.length>0"
+									@click="toNextChild(index,oneLevel,oneIndex)"></image>
-									:src="oneLevel.isOpen?'../../../static/icon_up_arrow.png':'../../../static/icon_drop_arrow.png'"
-									class="image" @click="toNextChild(index,oneLevel,oneIndex)"></image>
 								<view class="name" @click="toNextChild(index,oneLevel,oneIndex)">{{oneLevel.name}}
 								</view>
 								<view class="enter" @click="itemClick(oneLevel)">进入</view>
@@ -51,14 +58,75 @@
 	export default {
 		data() {
 			return {
+				key: "",
 				trees: [],
-				temp: []
+				temp: [],
+				treeProps: function() {
+					return {
+						label: 'name', // 指把数据中的‘personName’当做label也就是节点名称
+						children: 'children_list' // 指
+					}
+				},
+				currentKeys: []
 			}
 		},
 		onLoad() {
+			var currentId = uni.getStorageSync("org_id")
+			if (currentId) {
+				this.currentKeys.push(currentId)
+			}
+			console.log("当前选中", this.currentKey);
 			this.getOrgTree()
 		},
+		watch: {
+			key(val) {
+				this.$refs.tree.filter(val);
+			}
+		},
 		methods: {
+			handleNodeClick(obj) {
+				// console.log('handleNodeClick', obj);
+			},
+			handleNodeExpand(obj) {
+			},
+			filterNode(value, data) {
+				if (!value) return true;
+				// if (!data.label) return false
+				return data.name.indexOf(value) != -1;
+			},
+			toSwitch() {
+				var node = this.$refs.tree.getCheckedNodes()
+				if (node.length < 0) {
+					this.$toast.showToast("请选择切换的组织")
+					return
+				}
+				let that = this
+				uni.showModal({
+					title: '提示',
+					content: '确定切换到该组织？',
+					showCancel: true,
+					confirmText: "切换",
+					confirmColor: '#1890FF',
+					success: res => {
+						if (res.confirm) {
+							that.switchOrg(node[0])
+						}
+					}
+				})
+			},
+			setImgSrc(item) {
+				return item.isOpen ? '../../../static/icon_up_arrow.png' : '../../../static/icon_drop_arrow.png'
+			},
+			isImgShow(level) {
+				if (level.project_id) {
+					return false
+				}
+				if (level.children_list && level.children_list.length > 0) {
+					return true
+				}
+				return false
+			},
 			dealProject(list) {
 				var projects = []
 				list.forEach((item) => {
@@ -73,7 +141,8 @@
 				Api.getOrgTree({
 					data: {
 						company_id: uni.getStorageSync("company_id"),
-						org_no: getApp().globalData.userInfo.user.org_no
+						org_no: getApp().globalData.userInfo.user.org_no,
+						show_current_level: 1
 					}
 				}).then((result) => {
 					console.log("组织树", result);
@@ -85,11 +154,11 @@
 									item.dept_no == getApp().globalData.userInfo.user.dept_no
 								)
 							} else {
-								if (list[0].no == '001') {
+								// if (list[0].no == '001') {
-									this.trees = list[0].children_list
+								// 	this.trees = list[0].children_list
-								} else {
+								// } else {
-									this.trees = list
+								this.trees = list
-								}
+								// }
 							}
 							this.temp = list[0].children_list
 						}
@@ -156,62 +225,63 @@
 				})
 			},
 			search(e) {
-				var key = e.detail.value
+				// var key = e.detail.value
-				if (key) {
+				// this.$refs.tree.filter(key, null)
-					var list = []
+				// if (key) {
-					var sourceData = this.temp
+				// 	var list = []
-					console.log("数据源", sourceData);
+				// 	var sourceData = this.temp
-					sourceData.forEach((item) => {
+				// 	console.log("数据源", sourceData);
-						if (item.name.indexOf(key) != -1) {
+				// 	sourceData.forEach((item) => {
-							item.isOpen = true
+				// 		if (item.name.indexOf(key) != -1) {
-							list.push(item)
+				// 			item.isOpen = true
-						} else {
+				// 			list.push(item)
-							var children = item.children_list
+				// 		} else {
-							var childrens = []
+				// 			var children = item.children_list
-							if (children) {
+				// 			var childrens = []
-								children.forEach((child) => {
+				// 			if (children) {
-									if (child.name.indexOf(key) != -1) {
+				// 				children.forEach((child) => {
-										child.isOpen = true
+				// 					if (child.name.indexOf(key) != -1) {
-										var childs = child.children_list
+				// 						child.isOpen = true
-										var childList = []
+				// 						var childs = child.children_list
-										if (childs) {
+				// 						var childList = []
-											childs.forEach((childItem) => {
+				// 						if (childs) {
-												if (childItem.name.indexOf(key) != -1) {
+				// 							childs.forEach((childItem) => {
-													childList.push(childItem)
+				// 								if (childItem.name.indexOf(key) != -1) {
-												}
+				// 									childList.push(childItem)
-											})
+				// 								}
-										}
+				// 							})
-										child.children_list = childList
+				// 						}
-										childrens.push(child)
+				// 						child.children_list = childList
-									} else {
+				// 						childrens.push(child)
-										var childs = child.children_list
+				// 					} else {
-										var childList = []
+				// 						var childs = child.children_list
-										if (childs) {
+				// 						var childList = []
-											childs.forEach((childItem) => {
+				// 						if (childs) {
-												if (childItem.name.indexOf(key) != -1) {
+				// 							childs.forEach((childItem) => {
-													childList.push(childItem)
+				// 								if (childItem.name.indexOf(key) != -1) {
-												}
+				// 									childList.push(childItem)
-											})
+				// 								}
-										}
+				// 							})
-										if (childList.length > 0) {
+				// 						}
-											child.children_list = childList
+				// 						if (childList.length > 0) {
-											child.isOpen = true
+				// 							child.children_list = childList
-											childrens.push(child)
+				// 							child.isOpen = true
-										}
+				// 							childrens.push(child)
-									}
+				// 						}
-								})
+				// 					}
-							}
+				// 				})
-							if (childrens.length > 0) {
+				// 			}
-								item.isOpen = true
+				// 			if (childrens.length > 0) {
-								item.children_list = childrens
+				// 				item.isOpen = true
-								list.push(item)
+				// 				item.children_list = childrens
-							}
+				// 				list.push(item)
-						}
+				// 			}
-					})
+				// 		}
-					this.trees = list
+				// 	})
-				} else {
+				// 	this.trees = list
-					this.getOrgTree()
+				// } else {
-				}
+				// 	this.getOrgTree()
+				// }
 			}
 		}
@@ -227,7 +297,7 @@
 			display: flex;
 			flex-direction: row;
 			align-items: center;
-			margin: 30rpx 30rpx 0 30rpx;
+			margin: 30rpx;
 			.search-content {
 				display: flex;