潘钊 / bsth_control · Files

//自定义指令
/**
 * loading载入中指令。
 */
angular.module('ScheduleApp').directive('loadingWidget', ['requestNotificationChannel', function(requestNotificationChannel) {
    return {
        restrict: 'A',
        link: function(scope, element) {
            // 初始隐藏loading界面
            element.hide();

            // 开始请求通知处理
            requestNotificationChannel.onRequestStarted(scope, function() {
                element.show();
            });
            // 请求结束通知处理
            requestNotificationChannel.onRequestEnded(scope, function() {
                element.hide();
            });
        }
    };
}]);
/**
 * remoteValidation指令，远程数据验证验证，作为属性放在某个指令上，依赖与指令的ngModel。
 * 属性如下：
 * remotevtype（必须）：验证类型（在service中有对应映射），如rvtype="xl"
 * remotevparam（必须）：后端判定查询参数，如rvparam={{ {'xl.id_eq': '123'} | json }}
 *
 */
angular.module('ScheduleApp').directive('remoteValidation', [
    '$$SearchInfoService_g',
    function($$SearchInfoService_g) {
        return {
            restrict: "A", // 属性
            require: "^ngModel", // 依赖所属指令的ngModel
            compile: function(tElem, tAttrs) {
                // 验证属性
                if (!tAttrs["remotevtype"]) { // 验证类型
                    throw new Error("remotevtype属性必须填写");
                } else if (!$$SearchInfoService_g.validate[tAttrs["remotevtype"]]) {
                    throw new Error(!tAttrs["remotevtype"] + "验证类型不存在");
                }
                if (!tAttrs["remotevparam"]) { // 查询参数
                    throw new Error("remotevparam属性必须填写");
                }

                // 监听获取的数据
                var $watch_rvtype = undefined;
                var $watch_rvparam_obj = undefined;

                // 验证数据
                var $$internal_validate = function(ngModelCtrl) {
                    if ($watch_rvtype && $watch_rvparam_obj) {
                        // 获取查询参数模版
                        var paramTemplate = $$SearchInfoService_g.validate[$watch_rvtype].template;
                        if (!paramTemplate) {
                            throw new Error($watch_rvtype + "查询模版不存在");
                        }
                        // 判定如果参数对象不全，没有完全和模版参数里对应上，则不验证
                        var isParamAll = true;
                        for (var key in paramTemplate) {
                            if (!$watch_rvparam_obj[key]) {
                                isParamAll = false;
                                break;
                            }
                        }
                        if (!isParamAll) {
                            ngModelCtrl.$setValidity('remote', true);
                        } else { // 开始验证
                            $$SearchInfoService_g.validate[$watch_rvtype].remote.do(
                                $watch_rvparam_obj,
                                function(result) {
                                    if (result.status == "SUCCESS") {
                                        ngModelCtrl.$setValidity('remote', true);
                                    } else {
                                        ngModelCtrl.$setValidity('remote', false);
                                    }
                                },
                                function(result) {
                                    ngModelCtrl.$setValidity('remote', true);
                                }
                            );
                        }
                    }
                };

                return {
                    pre: function(scope, element, attr) {

                    },

                    post: function(scope, element, attr, ngModelCtrl) {
                        /**
                         * 监控验证类型属性变化。
                         */
                        attr.$observe("remotevtype", function(value) {
                            if (value && value != "") {
                                $watch_rvtype = value;
                                $$internal_validate(ngModelCtrl);
                            }
                        });
                        /**
                         * 监控查询结果属性变化。
                         */
                        attr.$observe("remotevparam", function(value) {
                            if (value && value != "") {
                                if (!ngModelCtrl.$dirty) { // 没有修改过模型数据，不验证
                                    return;
                                }
                                $watch_rvparam_obj = JSON.parse(value);
                                $$internal_validate(ngModelCtrl);
                            }
                        });
                    }
                };
            }
        }
    }
]);

/**
 * remoteValidatiot2指令，远程数据验证验证，作为属性放在某个指令上，依赖与指令的ngModel（专门用于时刻表sheet验证）。
 * 属性如下：
 * remotevtype（必须）：验证类型（在service中有对应映射），如rvtype="xl"
 * remotevparam（必须）：后端判定查询参数，如rvparam={{ {'xl.id_eq': '123'} | json }}
 *
 */
angular.module('ScheduleApp').directive('remoteValidationt2', [
    '$$SearchInfoService_g',
    function($$SearchInfoService_g) {
        return {
            restrict: "A", // 属性
            require: "^ngModel", // 依赖所属指令的ngModel
            compile: function(tElem, tAttrs) {
                // 验证属性
                if (!tAttrs["remotevtype"]) { // 验证类型
                    throw new Error("remotevtype属性必须填写");
                } else if (!$$SearchInfoService_g.validate[tAttrs["remotevtype"]]) {
                    throw new Error(!tAttrs["remotevtype"] + "验证类型不存在");
                }
                if (!tAttrs["remotevparam"]) { // 查询参数
                    throw new Error("remotevparam属性必须填写");
                }

                // 监听获取的数据
                var $watch_rvtype = undefined;
                var $watch_rvparam_obj = undefined;

                // 验证数据
                var $$internal_validate = function(ngModelCtrl, scope) {
                    if ($watch_rvtype && $watch_rvparam_obj) {
                        // 获取查询参数模版
                        var paramTemplate = $$SearchInfoService_g.validate[$watch_rvtype].template;
                        if (!paramTemplate) {
                            throw new Error($watch_rvtype + "查询模版不存在");
                        }
                        // 判定如果参数对象不全，没有完全和模版参数里对应上，则不验证
                        var isParamAll = true;
                        for (var key in paramTemplate) {
                            if (!$watch_rvparam_obj[key]) {
                                isParamAll = false;
                                break;
                            }
                        }
                        if (!isParamAll) {
                            ngModelCtrl.$setValidity('remote', true);
                        } else { // 开始验证
                            $$SearchInfoService_g.validate[$watch_rvtype].remote.do(
                                $watch_rvparam_obj,
                                function(result) {
                                    if (result.status == "SUCCESS") {
                                        ngModelCtrl.$setValidity('remote', true);
                                    } else {
                                        ngModelCtrl.$setValidity('remote', false);
                                        scope.ctrl.ttInfoDetailManageForForm.sheetvaliddesc = result.msg;
                                    }
                                },
                                function(result) {
                                    alert("出错拉");
                                    ngModelCtrl.$setValidity('remote', true);
                                }
                            );
                        }
                    }
                };

                return {
                    pre: function(scope, element, attr) {

                    },

                    post: function(scope, element, attr, ngModelCtrl) {
                        /**
                         * 监控验证类型属性变化。
                         */
                        attr.$observe("remotevtype", function(value) {
                            if (value && value != "") {
                                $watch_rvtype = value;
                                $$internal_validate(ngModelCtrl, scope);
                            }
                        });
                        /**
                         * 监控查询结果属性变化。
                         */
                        attr.$observe("remotevparam", function(value) {
                            if (value && value != "") {
                                //if (!ngModelCtrl.$dirty) { // 没有修改过模型数据，不验证
                                //    return;
                                //}
                                $watch_rvparam_obj = JSON.parse(value);
                                $$internal_validate(ngModelCtrl, scope);
                            }
                        });
                    }
                };
            }
        }
    }
]);


angular.module('ScheduleApp').directive("saSelect", ['$timeout', function($timeout) {
    return {
        restrict: 'E',
        templateUrl: '/pages/scheduleApp/module/common/dts1/select/saSelectTemplate.html',
        scope: {
            model: "="
        },
        controllerAs: "$saSelectCtrl",
        bindToController: true,
        controller: function() {
            var self = this;
            self.datas = []; // 关联的字典数据，内部格式 {code:{值},name:{名字}}
        },
        /**
         * 此阶段可以改dom结构，此时angular还没扫描指令，
         * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
         * @param tElem
         * @param tAttrs
         * @returns {{pre: Function, post: Function}}
         */
        compile: function(tElem, tAttrs) {
            // 确定是否使用angularjs required验证
            // 属性 required
            // 如果没有填写，内部不添加验证，如果填写了，并且等于true添加验证，否则不添加
            var required_attr = tAttrs["required"];
            if (required_attr) {
                if (required_attr == "true") {
                    // 添加required属性指令
                    tElem.find("ui-select").attr("required", "");
                } else {
                    // 不等于true，不添加required属性指令
                }
            } else {
                // 不添加required属性指令
            }

            //console.log("saSelect" + ":compile = >" + tElem.html());

            return {
                pre: function(scope, element, attr) {
                    // TODO：
                },
                /**
                 * 相当于link函数。
                 *
                 * 重要属性如下：
                 * model 是绑定外部值。
                 * dicgroup 字典组的类型
                 * name input name属性值
                 */
                post: function(scope, element, attr) {
                    // 1、获取属性
                    var dicgroup_attr = attr['dicgroup']; // 字典组的类型
                    var name_attr = attr['name']; // input name属性值
                    var dicname_attr = attr['dicname']; // model关联的字典名字段
                    var codename_attr = attr['codename']; // model关联的字典值字段
                    var placeholder_attr = attr['placeholder']; // select placeholder提示

                    // 系统的字典对象，使用dictionaryUtils类获取
                    var origin_dicgroup;
                    var dic_key; // 字典key

                    if (dicgroup_attr) { // 赋值指定的字典数据
                        origin_dicgroup = dictionaryUtils.getByGroup(dicgroup_attr);
                        for (dic_key in origin_dicgroup) {
                            var data = {}; // 重新组合的字典元素对象
                            if (dic_key == "true")
                                data.code = true;
                            else
                                data.code = dic_key;
                            data.name = origin_dicgroup[dic_key];
                            scope["$saSelectCtrl"].datas.push(data);
                        }
                    }

                    if (name_attr) {
                        scope["$saSelectCtrl"].nv = name_attr;
                    }
                    if (placeholder_attr) {
                        scope["$saSelectCtrl"].ph = placeholder_attr;
                    }

                    scope["$saSelectCtrl"].select = function($item) {
                        if (codename_attr) {
                            scope["$saSelectCtrl"].model[codename_attr] = $item.code;
                        }
                        if (dicname_attr) {
                            scope["$saSelectCtrl"].model[dicname_attr] = $item.name;
                        }
                    };

                    scope["$saSelectCtrl"].remove = function() {
                        if (codename_attr) {
                            scope["$saSelectCtrl"].model[codename_attr] = null;
                        }
                        if (dicname_attr) {
                            scope["$saSelectCtrl"].model[dicname_attr] = null;
                        }
                        scope["$saSelectCtrl"].cmodel = null;
                    };

                    $timeout(function() {
                        // 创建内部使用的绑定对象
                        var model_code = scope["$saSelectCtrl"].model[codename_attr];
                        scope["$saSelectCtrl"].cmodel = model_code;
                    }, 0);
                }
            }
        }
    };
}]);



angular.module('ScheduleApp').directive("saSelect2", [
    '$timeout', '$$SearchInfoService_g',
    function($timeout, $$searchInfoService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts1/select/saSelect2Template.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型对象
            },
            controllerAs: "$saSelectCtrl",
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // 内部关联的数据
            },
            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // 1、获取此阶段使用的属性
                var $required_attr = tAttrs["required"]; // 用于和表单验证连接，指定成required="true"才有效。

                // 2、处理属性

                // 确定是否使用angularjs required验证
                // 属性 required
                // 如果没有填写，内部不添加验证，如果填写了，并且等于true添加验证，否则不添加
                if ($required_attr) {
                    if ($required_attr == "true") {
                        // 添加required属性指令
                        tElem.find("ui-select").attr("required", "");
                    } else {
                        // 不等于true，不添加required属性指令
                    }
                } else {
                    // 不添加required属性指令
                }

                //console.log("saSelect" + ":compile = >" + tElem.html());

                return {
                    pre: function(scope, element, attr) {
                        // TODO：
                    },
                    /**
                     * 相当于link函数。
                     *
                     * 重要属性如下：
                     * model 是绑定外部值。
                     * dicgroup 字典组的类型
                     * name input name属性值
                     */
                    post: function(scope, element, attr) {
                        // 1、获取此阶段使用的属性
                        var $name_attr = attr["name"]; // 表单验证时需要的名字
                        var $type_attr = attr["type"]; // 关联的那种数据值（xl/cl/ry）-> 对应线路信息/车辆信息/人员信息，后面有的继续加
                        var $modelcolname1_attr = attr["modelcolname1"]; // 关联的模型字段名字1（一般应该是编码字段）
                        var $modelcolname2_attr = attr["modelcolname2"]; // 关联的模型字段名字2（一般应该是名字字段）
                        var $datacolname1_attr = attr["datacolname1"]; // 内部数据对应的字段名字1（与模型字段1对应）
                        var $datacolname2_attr = attr["datacolname2"]; // 内部数据对应的字段名字2（与模型字段2对应）
                        var $showcolname_attr = attr["showcolname"]; // 下拉框显示的内部数据字段名
                        var $placeholder_attr = attr["placeholder"]; // select placeholder字符串描述

                        // 2、处理属性、转换成$saSelectCtrl内部使用的属性
                        if ($name_attr) {
                            scope["$saSelectCtrl"].$name_attr = $name_attr;
                        }
                        if ($placeholder_attr) {
                            scope["$saSelectCtrl"].$placeholder_attr = $placeholder_attr;
                        }
                        if ($showcolname_attr) {
                            scope["$saSelectCtrl"].$showcolname_attr = $showcolname_attr;
                        }

                        // 2-1、添加内部方法，根据type值，改变$$data的值
                        scope["$saSelectCtrl"].$$internal_data_change_fn = function() {
                            // 根据type属性动态载入数据
                            if ($type_attr) {
                                $$searchInfoService_g[$type_attr].list(
                                    {type: "all"},
                                    function(result) {
                                        scope["$saSelectCtrl"].$$data = [];
                                        for (var i = 0; i < result.length; i ++) {
                                            var data = {}; // data是result的一部分属性集合，根据配置来确定
                                            if ($datacolname1_attr) {
                                                data[$datacolname1_attr] = result[i][$datacolname1_attr];
                                            }
                                            if ($datacolname2_attr) {
                                                data[$datacolname2_attr] = result[i][$datacolname2_attr];
                                            }
                                            if ($showcolname_attr) {
                                                // 动态添加基于名字的拼音
                                                data[$showcolname_attr] = result[i][$showcolname_attr];
                                                if (data[$showcolname_attr]) {
                                                    data["fullChars"] = pinyin.getFullChars(result[i][$showcolname_attr]).toUpperCase(); // 全拼
                                                    data["camelChars"] = pinyin.getCamelChars(result[i][$showcolname_attr]); // 简拼
                                                }
                                            }
                                            if (data["fullChars"])
                                                scope["$saSelectCtrl"].$$data.push(data);
                                        }
                                    },
                                    function(result) {

                                    }
                                );
                            }
                        };

                        // 3、选择、删除事件映射模型和内部数据对应的字段
                        scope["$saSelectCtrl"].$select_fn_attr = function($item) {
                            if ($modelcolname1_attr && $datacolname1_attr) {
                                scope["$saSelectCtrl"].model[$modelcolname1_attr] = $item[$datacolname1_attr];
                            }
                            if ($modelcolname2_attr && $datacolname2_attr) {
                                scope["$saSelectCtrl"].model[$modelcolname2_attr] = $item[$datacolname2_attr];
                            }
                        };
                        scope["$saSelectCtrl"].$remove_fn_attr = function() {
                            if ($modelcolname1_attr) {
                                scope["$saSelectCtrl"].model[$modelcolname1_attr] = null;
                            }
                            if ($modelcolname2_attr) {
                                scope["$saSelectCtrl"].model[$modelcolname2_attr] = null;
                            }
                            scope["$saSelectCtrl"].$$cmodel = null; // 内部模型清空

                            scope["$saSelectCtrl"].$$internal_data_change_fn();
                        };

                        // 4、搜索事件
                        scope["$saSelectCtrl"].$refreshdata_fn_attr = function($search) {
                            //var fullChars = pinyin.getFullChars($search).toUpperCase();
                            //var camelChars = pinyin.getCamelChars($search);
                            //
                            //console.log(fullChars + " " + camelChars);
                            // TODO：事件暂时没用，放着以后再说
                        };

                        // 5、全部载入后，输入的
                        $timeout(function() {
                            // 创建内部使用的绑定对象，用于确认选中那个值
                            scope["$saSelectCtrl"].$$cmodel = scope["$saSelectCtrl"].model[$modelcolname1_attr];

                            scope["$saSelectCtrl"].$$internal_data_change_fn();
                        }, 0);
                    }
                }
            }
        };
    }
]);





/**
 * saSelect3指令
 * 属性如下：
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * name（必须）：控件的名字
 * placeholder（可选）：占位符字符串
 * dcvalue（必须）：绑定的model字段值，如：dcvalue={{ctrl.employeeInfoForSave.xl.id}}
 * dcname（必须）：绑定的model字段名，如：dcname=xl.id
 * icname（必须）：内部与之对应的字段名，如：icname=code
 * dcname2（可选）：其他需要赋值的model字段名2，如：dcname2=xl.name
 * icname2（可选）：内部与之对应的字段名2，如：icname2=name
 * dcname3（可选）：其他需要赋值的model字段名3，如：dcname2=xl.name
 * icname3（可选）：内部与之对应的字段名3，如：icname2=name
 * icnames（必须）：用于用于显示，以及简评处理的内部数据字段，如：icnames=name
 * required（可选）：是否要用required验证
 * datatype（必须）：业务数据类型，有字典类型，动态数据类型，暂时写的死点
 * mlp（可选）：是否多级属性（这里假设外部model如果多级，内部model也是多级）
 *
 * 高级属性：
 * dataassociate（可选）：数据源是否关联属性（内部数据随外部指定的参数变化而变化）
 * dataparam（可选）：数据源关联的外部参数对象
 *
 */
angular.module('ScheduleApp').directive("saSelect3", [
    '$timeout',
    '$$SearchInfoService_g',
    function($timeout, $$searchInfoService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts1/select/saSelect3Template.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型object
            },
            controllerAs: "$saSelectCtrl",
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // ui-select显示用的数据源
                self.$$data_real= []; // 内部真实的数据源
            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // 获取所有的属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $placeholder_attr = tAttrs["placeholder"]; // 占位符的名字
                var $dcname_attr = tAttrs["dcname"]; // 绑定的model字段名
                var $icname_attr = tAttrs["icname"]; // 内部与之对应的字段名
                var $dcname2_attr = tAttrs["dcname2"]; // 其他需要赋值的model字段名2
                var $icname2_attr = tAttrs["icname2"]; // 内部与之对应的字段名2
                var $dcname3_attr = tAttrs["dcname3"]; // 其他需要赋值的model字段名3
                var $icname3_attr = tAttrs["icname3"]; // 内部与之对应的字段名3

                var $icname_s_attr = tAttrs["icnames"]; // 用于用于显示，以及简评处理的内部数据字段
                var $datatype_attr = tAttrs["datatype"]; // 内部业务数据类型
                var $required_attr = tAttrs["required"]; // 是否需要required验证
                var $mlp_attr = tAttrs["mlp"]; // 是否多级属性
                var $dataassociate_attr = tAttrs["dataassociate"]; // 数据源是否关联属性

                // controlAs名字
                var ctrlAs = "$saSelectCtrl";

                // 数据源初始化标志
                var $$data_init = false;
                // 如果有required属性，添加angularjs required验证
                if ($required_attr != undefined) {
                    tElem.find("ui-select").attr("required", "");
                }

                // 由于有的属性是多级的如xl.name，所以要在compile阶段重写属性绑定属性定义
                // 原来的设置：{{$select.selected[$saSelectCtrl.$icname_s]}}
                tElem.find("ui-select-match").html("{{$select.selected" + "." + $icname_s_attr + "}}");
                // 原来的设置：item[$saSelectCtrl.$icname] as item in $saSelectCtrl.$$data
                tElem.find("ui-select-choices").attr("repeat", "item" + "." + $icname_attr + " as item in $saSelectCtrl.$$data");
                // 原来的设置：item[$saSelectCtrl.$icname_s]
                tElem.find("ui-select-choices span").attr("ng-bind", "item" + "." + $icname_s_attr);
                // 原来的设置：{{$saSelectCtrl.$name}}
                tElem.find("ui-select").attr("name", $name_attr);
                // 原来的设置：{{$saSelectCtrl.$placeholder}}
                tElem.find("ui-select-match").attr("placeholder", $placeholder_attr);

                return {
                    pre: function(scope, element, attr) {
                        // TODO：
                    },
                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function(scope, element, attr) {
                        // 添加选中事件处理函数
                        scope[ctrlAs].$$internal_select_fn = function($item) {
                            if ($dcname_attr && $icname_attr) {
                                if ($mlp_attr) {
                                    eval("scope[ctrlAs].model" + "." + $dcname_attr + " = $item" + "." + $icname_attr + ";");
                                } else {
                                    scope[ctrlAs].model[$dcname_attr] = $item[$icname_attr];
                                }
                            }
                            if ($dcname2_attr && $icname2_attr) {
                                if ($mlp_attr) {
                                    eval("scope[ctrlAs].model" + "." + $dcname2_attr + " = $item" + "." + $icname2_attr + ";");
                                } else {
                                    scope[ctrlAs].model[$dcname2_attr] = $item[$icname2_attr];
                                }
                            }
                            if ($dcname3_attr && $icname3_attr) {
                                if ($mlp_attr) {
                                    eval("scope[ctrlAs].model" + "." + $dcname3_attr + " = $item" + "." + $icname3_attr + ";");
                                } else {
                                    scope[ctrlAs].model[$dcname3_attr] = $item[$icname3_attr];
                                }
                            }
                        };

                        // 删除选中事件处理函数
                        scope[ctrlAs].$$internal_remove_fn = function() {
                            scope[ctrlAs].$$internalmodel = undefined;
                            if ($mlp_attr) {
                                eval("scope[ctrlAs].model" + "." + $dcname_attr + " = undefined;");
                            } else {
                                scope[ctrlAs].model[$dcname_attr] = undefined;
                            }

                            if ($dcname2_attr) {
                                if ($mlp_attr) {
                                    eval("scope[ctrlAs].model" + "." + $dcname2_attr + " = undefined;");
                                } else {
                                    scope[ctrlAs].model[$dcname2_attr] = undefined;
                                }
                            }
                            if ($dcname3_attr) {
                                if ($mlp_attr) {
                                    eval("scope[ctrlAs].model" + "." + $dcname3_attr + " = undefined;");
                                } else {
                                    scope[ctrlAs].model[$dcname3_attr] = undefined;
                                }
                            }
                        };

                        /**
                         * 内部方法，读取字典数据作为数据源。
                         * @param dicgroup 字典类型，如：gsType
                         * @param ccol 代码字段名
                         * @param ncol 名字字段名
                         */
                        scope[ctrlAs].$$internal_dic_data = function(dicgroup, ccol, ncol) {
                            var origin_dicgroup = dictionaryUtils.getByGroup(dicgroup);
                            var dic_key; // 字典key
                            // 清空内部数据
                            scope[ctrlAs].$$data_real = [];
                            for (dic_key in origin_dicgroup) {
                                var data = {}; // 重新组合的字典元素对象
                                if (dic_key == "true")
                                    data[ccol] = true;
                                else
                                    data[ccol] = dic_key;
                                data[ncol] = origin_dicgroup[dic_key];
                                scope[ctrlAs].$$data_real.push(data);
                            }
                            // 这里直接将$$data_real数据深拷贝到$$data
                            angular.copy(scope[ctrlAs].$$data_real, scope[ctrlAs].$$data);

                            console.log(scope[ctrlAs].$$data);
                        };

                        /**
                         * TODO：这个方法有性能问题，result一多就会卡一卡，之后再解决把
                         * 内部方法，读取字典数据作为数据源。
                         * @param result 原始数据
                         * @param dcvalue 传入的关联数据
                         */
                        scope[ctrlAs].$$internal_other_data = function(result, dcvalue) {
                            console.log("start=" + dcvalue);
                            // 清空内部数据
                            scope[ctrlAs].$$data_real = [];
                            scope[ctrlAs].$$data = [];
                            for (var i = 0; i < result.length; i ++) {
                                if ($icname_s_attr) {
                                    if ($mlp_attr) {
                                        if (eval("result[i]" + "." + $icname_s_attr)) {
                                            // 全拼
                                            result[i]["fullChars"] = pinyin.getFullChars(eval("result[i]" + "." + $icname_s_attr)).toUpperCase();
                                            // 简拼
                                            result[i]["camelChars"] = pinyin.getCamelChars(eval("result[i]" + "." + $icname_s_attr));
                                        }
                                    } else {
                                        if (result[i][$icname_s_attr]) {
                                            // 全拼
                                            result[i]["fullChars"] = pinyin.getFullChars(result[i][$icname_s_attr]).toUpperCase();
                                            // 简拼
                                            result[i]["camelChars"] = pinyin.getCamelChars(result[i][$icname_s_attr]);
                                        }
                                    }
                                }

                                if (result[i]["fullChars"]) { // 有拼音的加入数据源
                                    scope[ctrlAs].$$data_real.push(result[i]);
                                }

                            }
                            //console.log("start2");

                            // 数量太大取前10条记录作为显示
                            if (angular.isArray(scope[ctrlAs].$$data_real)) {
                                // 先迭代循环查找已经传过来的值
                                if (scope[ctrlAs].$$data_real.length > 0) {
                                    if (dcvalue) {
                                        for (var j = 0; j < scope[ctrlAs].$$data_real.length; j++) {
                                            if (scope[ctrlAs].$$data_real[j][$icname_attr] == dcvalue) {
                                                scope[ctrlAs].$$data.push(angular.copy(scope[ctrlAs].$$data_real[j]));
                                                break;
                                            }
                                        }
                                    }
                                }
                                // 在插入剩余的数据
                                for (var k = 0; k < scope[ctrlAs].$$data_real.length; k++) {
                                    if (scope[ctrlAs].$$data.length < 10) {
                                        if ($mlp_attr) {
                                            if (eval("scope[ctrlAs].$$data_real[k]" + "." + $icname_attr + " != dcvalue")) {
                                                scope[ctrlAs].$$data.push(angular.copy(scope[ctrlAs].$$data_real[k]));
                                            }
                                        } else {
                                            if (scope[ctrlAs].$$data_real[k][$icname_attr] != dcvalue) {
                                                scope[ctrlAs].$$data.push(angular.copy(scope[ctrlAs].$$data_real[k]));
                                            }
                                        }
                                    } else {
                                        break;
                                    }
                                }
                            }

                            //console.log("end");
                        };

                        /**
                         * 判定一个对象是否为空对象。
                         * @param Obj
                         */
                        scope[ctrlAs].$$internal_isEmpty_obj = function(obj) {
                            console.log(typeof obj);

                            if (typeof obj === "object" && !(obj instanceof Array)) {
                                for (var prop in obj) {
                                    if (obj.hasOwnProperty(prop)) {
                                        return false;
                                    }
                                }
                                return true;
                            } else {
                                throw "必须是对象";
                            }
                        };

                        // 刷新数据
                        scope[ctrlAs].$$internal_refresh_fn = function(search) {
                            // 绑定的model字段值，此属性是绑定属性，只能在link阶段获取
                            var $dcvalue_attr = attr["dcvalue"];

                            console.log("刷新数据：" + $dcvalue_attr);

                            if (!$$data_init) { // 只初始化$$data_real一次，重新载入页面才能重新初始化
                                if (dictionaryUtils.getByGroup($datatype_attr)) { // 判定是否字典类型数据源
                                    scope[ctrlAs].$$internal_dic_data(
                                        $datatype_attr, $icname_attr, $icname_s_attr);
                                    if ($dcvalue_attr) {
                                        scope[ctrlAs].$$internalmodel = $dcvalue_attr;
                                    }
                                } else { // 非字典类型数据源
                                    if (!$dataassociate_attr) {
                                        $$searchInfoService_g[$datatype_attr].list(
                                            {type: "all"},
                                            function(result) {
                                                //console.log("ok：" + $datatype_attr);
                                                scope[ctrlAs].$$internal_other_data(result, $dcvalue_attr);
                                                //console.log("ok2：" + $datatype_attr);
                                                if ($dcvalue_attr) {
                                                    scope[ctrlAs].$$internalmodel = $dcvalue_attr;
                                                }

                                                $$data_init = true;
                                            },
                                            function(result) {

                                            }
                                        );
                                    }
                                }
                            }

                            if ($$data_init) {
                                if (search && search != "") { // 有search值
                                    if (!dictionaryUtils.getByGroup($datatype_attr)) { // 其他数据源
                                        // 处理search
                                        console.log("search:" + search);

                                        scope[ctrlAs].$$data = [];
                                        for (var k = 0; k < scope[ctrlAs].$$data_real.length; k++) {
                                            var upTerm = search.toUpperCase();
                                            if (scope[ctrlAs].$$data.length < 10) {
                                                if (scope[ctrlAs].$$data_real[k].fullChars.indexOf(upTerm) != -1
                                                    || scope[ctrlAs].$$data_real[k].camelChars.indexOf(upTerm) != -1) {
                                                    scope[ctrlAs].$$data.push(angular.copy(scope[ctrlAs].$$data_real[k]));
                                                }
                                            } else {
                                                break;
                                            }
                                        }
                                    }
                                }

                            }

                        };










                        // TODO：

                        // dom全部载入后调用
                        $timeout(function() {
                            console.log("dom全部载入后调用");
                        }, 0);
                        // 监控dcvalue model值变换
                        attr.$observe("dcvalue", function(value) {
                                console.log("监控dc1 model值变换：" + value);
                                scope[ctrlAs].$$internalmodel = value;
                            }
                        );
                        // 监控获取数据参数变换
                        attr.$observe("dataparam", function(value) {
                                // 判定是否空对象
                                console.log(value);
                                var obj = JSON.parse(value);
                                var $dcvalue_attr = attr["dcvalue"];
                                if (!scope[ctrlAs].$$internal_isEmpty_obj(obj)) {
                                    console.log("dataparam：" + obj);

                                    //

                                    obj["type"] = "all";

                                    $$data_init = false;
                                    $$searchInfoService_g[$datatype_attr].list(
                                        obj,
                                        function(result) {
                                            //console.log("ok：" + $datatype_attr);
                                            scope[ctrlAs].$$internal_other_data(result, $dcvalue_attr);
                                            //console.log("ok2：" + $datatype_attr);
                                            if ($dcvalue_attr) {
                                                scope[ctrlAs].$$internalmodel = $dcvalue_attr;
                                            }

                                            $$data_init = true;
                                        },
                                        function(result) {

                                        }
                                    );
                                }
                            }
                        );
                    }
                };
            }
        };

    }
]);


/**
 * saSelect4指令，封装angular-ui-select控件，并添加相应的业务。
 * name（必须）：控件的名字
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * placeholder（可选）：输入框占位符字符串
 *
 * dcvalue（必须）：绑定的model字段值，如：dcvalue={{ctrl.employeeInfoForSave.xl.id}}
 * dcname（必须）：绑定的model字段名，如：dcname=xl.id
 * icname（必须）：内部与之对应的字段名，如：icname=code
 *
 * cmaps（可选）：model其他字段和内部数据字段名映射，如：{{ {'xl.id' : 'id', 'xl.name' : 'name'} | json}}
 * dsparams（必须）：内部数据源查询参数，如：{{ {'ttid': ctrl.rerunManageForSave.rerunTtinfo.id} | json }}
 * dscol（必须）：内部显示的信息（暂时用内部字段），如：dscol=name
 * required（可选）：是否要用required验证
 */
angular.module('ScheduleApp').directive('saSelect4', [
    '$timeout',
    '$$SearchInfoService_g',
    function($timeout, $$searchInfoService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts1/select/saSelect4Template.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型object
            },
            controllerAs: "$saSelectCtrl",
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // ui-select显示用的数据
                self.$$data_real = []; // 内部真实的数据

                // saSelect4组件的ng-model，用于外部绑定验证等操作
                self.$$internalmodel = undefined;

                self.$$internal_select_value = undefined; // 选中的值
            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // 获取属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $placeholder_attr = tAttrs["placeholder"]; // 占位符的名字

                var $dcname_attr = tAttrs["dcname"]; // 绑定的model字段名
                var $icname_attr = tAttrs["icname"]; // 内部与之对应的字段名

                var $cmaps_attr = tAttrs["cmaps"]; // model其他字段和内部数据字段名映射
                var $dscol_attr = tAttrs["dscol"]; // 内部显示的信息
                var $required_attr = tAttrs["required"]; // 是否需要required验证

                // controlAs名字
                var ctrlAs = "$saSelectCtrl";

                // 验证属性
                if (!$name_attr) {
                    throw new error("name属性必须填写");
                }
                if (!$dcname_attr) {
                    throw new error("dcname属性必须填写");
                }
                if (!$icname_attr) {
                    throw new error("icname属性必须填写");
                }
                if (!$dscol_attr) {
                    throw new error("dscol属性必须填写");
                }

                // 动态设置dom
                // dom required 属性
                if ($required_attr != undefined) {
                    tElem.find("div").attr("required", "");
                }
                // dom placeholder 属性
                tElem.find("ui-select-match").attr("placeholder", $placeholder_attr);
                // dom dscol 属性
                tElem.find("ui-select-match").html("{{$select.selected" + "." + $dscol_attr + "}}");
                tElem.find("ui-select-choices span").attr("ng-bind", "item" + "." + $dscol_attr);
                // dom icname 属性
                tElem.find("ui-select-choices").attr("repeat", "item" + "." + $icname_attr + " as item in $saSelectCtrl.$$data");
                // dom name 属性
                tElem.find("div").attr("name", $name_attr);

                return {
                    pre: function(scope, element, attr) {
                        // TODO：
                    },

                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function(scope, element, attr) {

                        // 添加选中事件处理函数
                        scope[ctrlAs].$$internal_select_fn = function($item) {
                            if ($dcname_attr && $icname_attr) {
                                eval("scope[ctrlAs].model" + "." + $dcname_attr + " = $item" + "." + $icname_attr + ";");
                            }

                            if ($cmaps_attr) {
                                for (var mc in $cmaps_attr) { // model的字段名:内部数据源对应字段名
                                    var ic = $cmaps_attr[mc]; // 内部数据源对应字段
                                    eval("scope[ctrlAs].model" + "." + mc + " = $item" + "." + ic + ";");
                                }
                            }
                        };

                        // 删除选中事件处理函数
                        scope[ctrlAs].$$internal_remove_fn = function() {
                            scope[ctrlAs].$$internal_select_value = undefined;
                            if ($dcname_attr) {
                                eval("scope[ctrlAs].model" + "." + $dcname_attr + " = undefined;");
                            }

                            if ($cmaps_attr) {
                                var mc; // model的字段名
                                for (mc in $cmaps_attr) {
                                    eval("scope[ctrlAs].model" + "." + mc + " = undefined;");
                                }
                            }
                            scope[ctrlAs].$$internal_validate_model();
                        };

                        // 刷新数据
                        scope[ctrlAs].$$internal_refresh_fn = function(search) {
                            if (search && search != "") { // 有search值
                                // 处理search
                                console.log("search:" + search);

                                scope[ctrlAs].$$data = [];
                                for (var k = 0; k < scope[ctrlAs].$$data_real.length; k++) {
                                    var upTerm = search.toUpperCase();
                                    if (scope[ctrlAs].$$data.length < 10) {
                                        if (scope[ctrlAs].$$data_real[k].fullChars.indexOf(upTerm) != -1
                                            || scope[ctrlAs].$$data_real[k].camelChars.indexOf(upTerm) != -1) {
                                            scope[ctrlAs].$$data.push(angular.copy(scope[ctrlAs].$$data_real[k]));
                                        }
                                    } else {
                                        break;
                                    }
                                }
                            }
                        };

                        /**
                         * 验证内部数据，更新外部model
                         */
                        scope[ctrlAs].$$internal_validate_model = function() {
                            if (scope[ctrlAs].$$internal_select_value) {
                                var select_value_temp = scope[ctrlAs].$$internal_select_value;
                                if (scope[ctrlAs].$$data_real && scope[ctrlAs].$$data_real.length > 0) {
                                    var obj;
                                    for (var j = 0; j < scope[ctrlAs].$$data_real.length; j++) {
                                        if (eval("scope[ctrlAs].$$data_real[j]" + "." + $icname_attr + " == select_value_temp")) {
                                            obj = angular.copy(scope[ctrlAs].$$data_real[j]);
                                            break;
                                        }
                                    }
                                    if (obj) { // 在data中判定有没有
                                        for (var k = 0; k < scope[ctrlAs].$$data.length; k++) {
                                            if (eval("scope[ctrlAs].$$data[k]" + "." + $icname_attr + " == obj." + $icname_attr)) {
                                                obj = undefined;
                                                break;
                                            }
                                        }
                                        if (obj) {
                                            scope[ctrlAs].$$data.push(obj);
                                        }
                                        // 更新内部model，用于外部验证
                                        // 内部model的值暂时随意，以后再改
                                        scope[ctrlAs].$$internalmodel = {desc: "ok"};
                                    } else {
                                        scope[ctrlAs].$$internalmodel = undefined;
                                    }

                                } else {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                }

                            } else {
                                scope[ctrlAs].$$internalmodel = undefined;
                            }
                        };

                        /**
                         * 内部方法，读取字典数据作为数据源。
                         * @param atype ajax查询类型
                         * @param ajaxparamobj 查询参数对象
                         */
                        scope[ctrlAs].$$internal_ajax_data = function(atype, ajaxparamobj) {
                            ajaxparamobj.type = 'all';
                            $$searchInfoService_g[atype].list(
                                ajaxparamobj,
                                function(result) {
                                    console.log("$$internal_ajax_data result");

                                    // 清空内部数据
                                    scope[ctrlAs].$$data_real = [];
                                    scope[ctrlAs].$$data = [];

                                    // result中添加拼音数据，注意：这里要求result返回对象数组
                                    for (var i = 0; i < result.length; i ++) {
                                        if ($dscol_attr) {
                                            if (eval("result[i]" + "." + $dscol_attr)) {
                                                // 全拼
                                                result[i]["fullChars"] = pinyin.getFullChars(eval("result[i]" + "." + $dscol_attr)).toUpperCase();
                                                // 简拼
                                                result[i]["camelChars"] = pinyin.getCamelChars(eval("result[i]" + "." + $dscol_attr));
                                            }
                                        }

                                        if (result[i]["fullChars"]) { // 有拼音的加入数据源
                                            scope[ctrlAs].$$data_real.push(result[i]);
                                        }

                                    }

                                    // 数据量太大，取10条记录显示
                                    if (angular.isArray(scope[ctrlAs].$$data_real)) {
                                        for (var k = 0; k < scope[ctrlAs].$$data_real.length; k++) {
                                            if (scope[ctrlAs].$$data.length < 10) {
                                                scope[ctrlAs].$$data.push(angular.copy(scope[ctrlAs].$$data_real[k]));
                                            } else {
                                                break;
                                            }
                                        }
                                    }

                                    scope[ctrlAs].$$internal_validate_model();
                                },
                                function(result) {

                                }
                            );
                        };

                        /**
                         * 内部方法，读取字典数据作为数据源。
                         * @param dictype 字典类型，如：gsType
                         */
                        scope[ctrlAs].$$internal_dic_data = function(dictype) {
                            if (!dictionaryUtils.getByGroup(dictype)) {
                                throw new error("字典数据不窜在=" + dictype);
                            }

                            // 清空内部数据
                            scope[ctrlAs].$$data_real = [];
                            scope[ctrlAs].$$data = [];

                            var origin_dicgroup = dictionaryUtils.getByGroup(dicgroup);
                            var dic_key; // 字典key

                            for (dic_key in origin_dicgroup) {
                                var data = {}; // 重新组合的字典元素对象
                                if (dic_key == "true")
                                    data[$icname_attr] = true;
                                else
                                    data[$icname_attr] = dic_key;
                                data[$dscol_attr] = origin_dicgroup[dic_key];
                                scope[ctrlAs].$$data_real.push(data);
                            }
                            // 这里直接将$$data_real数据深拷贝到$$data
                            angular.copy(scope[ctrlAs].$$data_real, scope[ctrlAs].$$data);
                            scope[ctrlAs].$$internal_validate_model();
                        };

                        attr.$observe("dsparams", function(value) {
                            if (value && value != "") {
                                var obj = JSON.parse(value);
                                console.log("observe 监控 dsparams=" + obj);

                                // dsparams格式如下：
                                // {type: 'dic/ajax', param: 'dic名字'/'ajax查询参数对象', atype: 'ajax查询类型'}

                                if (obj.type == 'dic') {
                                    scope[ctrlAs].$$internal_dic_data(obj.param);

                                } else if (obj.type == 'ajax') {
                                    scope[ctrlAs].$$internal_ajax_data(obj.atype, obj.param);
                                } else {
                                    throw new Error("dsparams参数格式异常=" + obj);
                                }

                            }

                        });

                        // 监控model绑定的dcvalue值变化
                        attr.$observe("dcvalue", function(value) {
                            if (value && value != "") {
                                console.log("observe 监控 dcvalue=" + value);
                                scope[ctrlAs].$$internal_select_value = value;
                                scope[ctrlAs].$$internal_validate_model();
                            }

                            // 闭包测试
                            var obj = {'a':1,'b':2};
                            var tfx = scope[ctrlAs].$$test.bind(obj);
                            console.log("闭包测试=" + tfx());
                        });

                        scope[ctrlAs].$$test = function() {
                            var exp = "this.a + '(' + this.b + ')'";
                            console.log("exp=" + exp);
                            return eval(exp);
                        };
                    }
                };

            }

        };
    }
]);
/**
 * saSelect5指令，基于简拼查询的select，内部封装angular-ui-select控件，并嵌入相应的业务逻辑。
 * name（必须）：控件的名字
 * model（必须）：独立作用域，指定一个外部对象模型双向绑定，如：model=ctrl.employeeInfoForSave
 * cmaps（必须）：外部对象与指令内部数据对象字段名映射对象字符串，如：{'xl.id' : 'id', 'xl.name' : 'name'}
 * dcname（必须）：绑定的model字段名，如：dcname=xl.id
 * icname（必须）：内部与之对应的字段名，如：icname=id
 *
 * dsparams（必须）：内部数据源查询参数对象，如：{{ {'ttid_eq': ctrl.rerunManageForSave.rerunTtinfo.id} | json }}
 * dsparamsextra（可选）：内部数据源查询附加参数对象字符串，如：{'type':'all'}
 * iterobjname（必须）：内部数据源迭代的数据变量名，如：iterobjname=item
 * iterobjexp（必须）：内部显示用的表达式
 * searchph（必须）：查询输入占位符字符串，如：searchph=请输入...
 * searchexp（必须）：查询基于的内部数据源的表达式，如：searchexp=this.name+'('+this.code+')'
 *
 * required（可选）：是否需要form的required验证
 *
 */
angular.module('ScheduleApp').directive('saSelect5', [
    '$timeout',
    '$$SearchInfoService_g',
    function($timeout, $$searchInfoService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts1/select/saSelect5Template.html',
            scope: { // 独立作用域
                model: "=" // 绑定外部对象
            },
            controllerAs: "$saSelectCtrl",
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // 内部ui-select显示用数据
                self.$$data_real = []; // 内部保存的实际数据

                // myselect组件的ng-model，用于外部绑定验证等操作
                self.$$internalmodel = undefined;

                self.$$internal_select_value = undefined; // 选中的值

            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // 获取属性，并验证必须按属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $cmaps_attr = tAttrs["cmaps"]; // 外部对象与指令内部数据对象字段名映射对象
                var $dcname_attr = tAttrs["dcname"]; // 绑定的model字段名
                var $icname_attr = tAttrs["icname"]; // 内部与之对应的字段名

                var $dsparams_attr = tAttrs["dsparams"]; // 内部数据源查询参数对象
                var $dsparamsextra_attr = tAttrs["dsparamsextra"]; // 内部数据源查询附加参数对象字符串
                var $iterobjname_attr = tAttrs["iterobjname"]; // 内部数据源迭代的数据变量名
                var $iterobjexp_attr = tAttrs["iterobjexp"]; // 内部显示用的表达式
                var $searchph_attr = tAttrs["searchph"]; // 查询输入占位符字符串
                var $searchexp_attr = tAttrs["searchexp"]; // 查询基于的内部数据源的表达式

                var $required_attr = tAttrs["required"]; // 是否需要required验证

                if (!$name_attr) {
                    throw new Error("name属性必须填写");
                }
                if (!$cmaps_attr) {
                    throw new Error("cmaps属性必须填写")
                }
                if (!$dcname_attr || !$icname_attr) {
                    throw new Error("dcname、icname属性必须填写");
                }
                if (!$dsparams_attr) {
                    throw new Error("dsparams属性必须填写");
                }
                if (!$iterobjname_attr) {
                    throw new Error("iterobjname属性必须填写");
                }
                if (!$iterobjexp_attr) {
                    throw new Error("iterobjexp属性必须填写");
                }
                if (!$searchph_attr) {
                    throw new Error("searchph属性必须填写");
                }
                if (!$searchexp_attr) {
                    throw new Error("searchexp属性必须填写");
                }

                // 内部controlAs名字
                var ctrlAs = "$saSelectCtrl";

                // 动态设置dom
                // dom，最外层name属性设置
                tElem.find("div:first").attr("name", $name_attr);
                // dom，最外层divrequired属性设置
                if ($required_attr != undefined) {
                    tElem.find("div[name=\'" + $name_attr + "\']").attr("required", "");
                }
                // dom，ui-select-match的placeholder属性设定
                tElem.find("ui-select-match").attr("placeholder", $searchph_attr);
                // dom，ui-select-match的内容设定
                var uiSelectMatchHtml = "{{" + ctrlAs + ".$$internal_match_str($select.selected)}}";
                tElem.find("ui-select-match").html(uiSelectMatchHtml);
                // dom，ui-select-choices的repeat属性设定
                var uiSelectChoices_repeatAttr = $iterobjname_attr + "." + $icname_attr + " as " + $iterobjname_attr + " in " + ctrlAs + ".$$data";
                tElem.find("ui-select-choices").attr("repeat", uiSelectChoices_repeatAttr);
                // dom，span ng-bind属性设置，TODO：暂时无法用transclude设置，先用属性设置
                tElem.find("ui-select-choices").html("{{" + $iterobjexp_attr + "}}");

                return {
                    pre: function (scope, element, attr) {
                        // TODO：
                    },

                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function (scope, element, attr) {

                        // 添加选中事件处理函数
                        scope[ctrlAs].$$internal_select_fn = function($item) {
                            eval("scope[ctrlAs].model" + "." + $dcname_attr + " = $item" + "." + $icname_attr + ";");

                            eval("var obj=" + $cmaps_attr);
                            for (var mc in obj) { // model的字段名:内部数据源对应字段名
                                var ic = obj[mc]; // 内部数据源对应字段
                                eval("scope[ctrlAs].model" + "." + mc + " = $item" + "." + ic + ";");
                            }
                        };

                        // 删除选中事件处理函数
                        scope[ctrlAs].$$internal_remove_fn = function() {
                            eval("scope[ctrlAs].model" + "." + $dcname_attr + " = undefined;");

                            eval("var obj=" + $cmaps_attr);
                            var mc; // model的字段名
                            for (mc in obj) {
                                eval("scope[ctrlAs].model" + "." + mc + " = undefined;");
                            }
                        };

                        // 刷新数据
                        scope[ctrlAs].$$internal_refresh_fn = function(search) {
                            if (search && search != "") { // 有search值
                                // 处理search
                                console.log("search:" + search);

                                scope[ctrlAs].$$data = [];
                                for (var k = 0; k < scope[ctrlAs].$$data_real.length; k++) {
                                    var upTerm = search.toUpperCase();
                                    if (scope[ctrlAs].$$data.length < 10) {
                                        if (scope[ctrlAs].$$data_real[k].$fullChars.indexOf(upTerm) != -1
                                            || scope[ctrlAs].$$data_real[k].$camelChars.indexOf(upTerm) != -1
                                            || scope[ctrlAs].$$data_real[k].$calcu_str.indexOf(upTerm) != -1) {
                                            scope[ctrlAs].$$data.push(angular.copy(scope[ctrlAs].$$data_real[k]));
                                        }
                                    } else {
                                        break;
                                    }
                                }
                            }
                        };

                        /**
                         * 验证内部数据，更新外部model
                         */
                        scope[ctrlAs].$$internal_validate_model = function() {
                            if (scope[ctrlAs].$$internal_select_value) {
                                var select_value_temp = scope[ctrlAs].$$internal_select_value;
                                if (scope[ctrlAs].$$data_real && scope[ctrlAs].$$data_real.length > 0) {
                                    var obj;
                                    for (var j = 0; j < scope[ctrlAs].$$data_real.length; j++) {
                                        if (eval("scope[ctrlAs].$$data_real[j]" + "." + $icname_attr + " == select_value_temp")) {
                                            obj = angular.copy(scope[ctrlAs].$$data_real[j]);
                                            break;
                                        }
                                    }
                                    if (obj) { // 在data中判定有没有
                                        for (var k = 0; k < scope[ctrlAs].$$data.length; k++) {
                                            if (eval("scope[ctrlAs].$$data[k]" + "." + $icname_attr + " == obj." + $icname_attr)) {
                                                obj = undefined;
                                                break;
                                            }
                                        }
                                        if (obj) {
                                            scope[ctrlAs].$$data.push(obj);
                                        }
                                        // 更新内部model，用于外部验证
                                        // 内部model的值暂时随意，以后再改
                                        scope[ctrlAs].$$internalmodel = {desc: "ok"};
                                    } else {
                                        scope[ctrlAs].$$internalmodel = undefined;
                                    }

                                } else {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                }

                            } else {
                                scope[ctrlAs].$$internalmodel = undefined;
                            }
                        };

                        /**
                         * 内部match表达式转换函数，需要外部绑定此函数的上下文。
                         * @param context function上下文
                         */
                        scope[ctrlAs].$$internal_match_str = function (context) {
                            var fx = function() {
                                try {
                                    return eval($searchexp_attr);
                                } catch (err) {
                                    //console.log(err);
                                    return undefined;
                                }

                            };

                            var str = fx.bind(context)();
                            if (str && str != "")
                                return str;
                            else
                                return undefined;
                        };

                        /**
                         * 内部方法，读取字典数据作为数据源。
                         * @param atype ajax查询类型
                         * @param ajaxparamobj 查询参数对象
                         */
                        scope[ctrlAs].$$internal_ajax_data = function(atype, ajaxparamobj) {
                            // 如果ajaxparamobj为空对象，则表示清空内部选项
                            var isEmptyObj = true;
                            for (var name in ajaxparamobj) {
                                isEmptyObj = false;
                            }
                            if (isEmptyObj) {
                                // 重新创建内部保存的数据
                                scope[ctrlAs].$$data_real = [];
                                // 重新创建内部ui-select显示用数据，默认取10条记录显示
                                scope[ctrlAs].$$data = [];

                                scope[ctrlAs].$$internal_remove_fn();
                                scope[ctrlAs].$$internal_validate_model();

                                return;
                            }

                            if ($dsparamsextra_attr) { // 合并附加参数
                                eval("var extra = " + $dsparamsextra_attr);
                                for (var extrakey in extra) {
                                    ajaxparamobj[extrakey] = extra[extrakey];
                                }
                            }

                            $$searchInfoService_g[atype].list(
                                ajaxparamobj,
                                function(result) {
                                    console.log("$$internal_ajax_data result");

                                    // 重新创建内部保存的数据
                                    scope[ctrlAs].$$data_real = [];
                                    // result中添加拼音数据，注意：这里要求result返回对象数组
                                    for (var i = 0; i < result.length; i++) {
                                        // 闭包绑定返回最终查询的值
                                        var calcu_str = scope[ctrlAs].$$internal_match_str(result[i]);
                                        if (calcu_str) {
                                            // 全拼
                                            result[i]["$fullChars"] = pinyin.getFullChars(calcu_str);
                                            // 简拼
                                            result[i]["$camelChars"] = pinyin.getCamelChars(calcu_str);
                                            // 原值
                                            result[i]["$calcu_str"] = calcu_str;

                                            scope[ctrlAs].$$data_real.push(result[i]);
                                        }
                                    }

                                    // 重新创建内部ui-select显示用数据，默认取10条记录显示
                                    scope[ctrlAs].$$data = [];
                                    for (var k = 0; k < scope[ctrlAs].$$data_real.length; k++) {
                                        if (scope[ctrlAs].$$data.length < 10) {
                                            scope[ctrlAs].$$data.push(scope[ctrlAs].$$data_real[k]);
                                        } else {
                                            break;
                                        }
                                    }

                                    scope[ctrlAs].$$internal_validate_model();
                                },
                                function(result) {
                                    throw new Error("ajax查询出错");
                                }
                            );
                        };

                        /**
                         * 内部方法，读取字典数据作为数据源。
                         * @param dictype 字典类型，如：gsType
                         */
                        scope[ctrlAs].$$internal_dic_data = function(dictype) {
                            if (!dictionaryUtils.getByGroup(dictype)) {
                                throw new error("字典数据不窜在=" + dictype);
                            }

                            // 重新创建内部保存的数据
                            scope[ctrlAs].$$data_real = [];
                            var origin_dicgroup = dictionaryUtils.getByGroup(dicgroup);
                            var dic_key; // 字典key

                            for (dic_key in origin_dicgroup) {
                                var data = {}; // 重新组合的字典元素对象
                                if (dic_key == "true")
                                    data[$icname_attr] = true;
                                else
                                    data[$icname_attr] = dic_key;
                                data[$dscol_attr] = origin_dicgroup[dic_key];
                                scope[ctrlAs].$$data_real.push(data);
                            }

                            // 重新创建内部ui-select显示用数据，直接复制所有的字典数据
                            scope[ctrlAs].$$data = [];
                            for (var k = 0; k < scope[ctrlAs].$$data_real.length; k++) {
                                scope[ctrlAs].$$data.push(scope[ctrlAs].$$data_real[k]);
                            }

                            scope[ctrlAs].$$internal_validate_model();
                        };

                        /**
                         * 内部方法，读取本地动态数据源。
                         * @param ldata
                         */
                        scope[ctrlAs].$$internal_local_data = function(ldata) {
                            // 重新创建内部保存的数据
                            scope[ctrlAs].$$data_real = [];
                            // 重新创建内部ui-select显示用数据，默认取10条记录显示
                            scope[ctrlAs].$$data = [];

                            // 本地动态数据直接显示，暂时不优化
                            for (var i = 0; i < ldata.length; i++) {
                                scope[ctrlAs].$$data_real.push(ldata[i]);
                                scope[ctrlAs].$$data.push(ldata[i]);
                            }

                            scope[ctrlAs].$$internal_validate_model();
                        };

                        /**
                         * 监控dsparams属性变化
                         */
                        attr.$observe("dsparams", function(value) {
                            if (value && value != "") {
                                var obj = JSON.parse(value);
                                console.log("saSelect5 监控到dsparams属性变化，old=" + $dsparams_attr + "，new=" + value);

                                // dsparams格式如下：
                                // {type: 'dic/ajax', param: 'dic名字'/'ajax查询参数对象', atype: 'ajax查询类型'}

                                if (obj.type == 'dic') {
                                    scope[ctrlAs].$$internal_dic_data(obj.param);

                                } else if (obj.type == 'ajax') {
                                    scope[ctrlAs].$$internal_ajax_data(obj.atype, obj.param);
                                } else if (obj.type == 'local') {
                                    scope[ctrlAs].$$internal_local_data(obj.ldata);
                                } else {
                                    throw new Error("dsparams参数格式异常=" + obj);
                                }

                            }
                        });

                        /**
                         * 监控外部模型dcname的值的变化。
                         */
                        scope.$watch(
                            function() {
                                return eval("scope." + ctrlAs + ".model" + "." + $dcname_attr);
                            },
                            function(newValue, oldValue) {
                                if (newValue === undefined && oldValue === undefined) {
                                    // 两侧都是undefined，不处理

                                } else {
                                    console.log("saSelect5 监控到外部模型" + $dcname_attr + "属性值变化，old=" + oldValue + "，new=" + newValue);
                                    scope[ctrlAs].$$internal_select_value = newValue;
                                    scope[ctrlAs].$$internal_validate_model();
                                }
                            },
                            true
                        );
                    }
                };
            }
        };
    }
]);

/**
 * saRadiogroup指令
 * 属性如下：
 * model（必须）：独立作用域，外部绑定的一个值，如：ctrl.timeTableManageForForm.isEnableDisTemplate
 * dicgroup（必须）：关联的字典数据type（TODO：以后增加其他数据源）
 * name（必须）：控件的名字
 * required（可选）：是否要用required验证
 * disabled（可选）：标示单选框是否可选
 *
 */
angular.module('ScheduleApp').directive("saRadiogroup", [function() {
    /**
     * 使用字典数据的单选按钮组的指令。
     * 指令名称：truefalse-Dic
     */
    return {
        restrict: 'E',
        templateUrl: '/pages/scheduleApp/module/common/dts1/radioButton/saRadiogroupTemplate.html',
        scope: {
            model: "="
        },
        controllerAs: "$saRadiogroupCtrl",
        bindToController: true,
        controller: function($scope) {
            //$scope["model"] = {selectedOption: null};
            //console.log("controller");
            //console.log("controller:" + $scope["model"]);

            var self = this;
            self.$$data = null; // 内部数据
        },

        /**
         * 此阶段可以改dom结构，此时angular还没扫描指令，
         * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
         * @param tElem
         * @param tAttrs
         * @returns {{pre: Function, post: Function}}
         */
        compile: function(tElem, tAttrs) {
            // 获取属性
            var $dicgroup_attr = tAttrs["dicgroup"]; // 关联的字典数据type
            var $name_attr = tAttrs["name"]; // 控件的名字
            var $required_attr = tAttrs["required"]; // 是否要用required验证
            var $disabled_attr = tAttrs["disabled"]; // 标示单选框是否可选

            // controlAs名字
            var ctrlAs = "$saRadiogroupCtrl";

            // 如果有required属性，添加angularjs required验证
            if ($required_attr != undefined) {
                tElem.find("input").attr("required", "");
            }

            return {
                pre: function(scope, element, attr) {

                },

                /**
                 * 相当于link函数。
                 * @param scope
                 * @param element
                 * @param attr
                 */
                post: function(scope, element, attr) {
                    //console.log("link");
                    //console.log("link:" + scope.model);
                    //scope["model"] = {selectedOption: null};

                    if ($name_attr) {
                        scope[ctrlAs].nv = $name_attr;
                    }

                    if ($disabled_attr) {
                        scope[ctrlAs].disabled = true;
                    }
                    if ($dicgroup_attr) {
                        var obj = dictionaryUtils.getByGroup($dicgroup_attr);
                        scope[ctrlAs].$$data = obj;
                        // 处理 scope["dic"] key值
                        scope[ctrlAs].dicvalueCalcu = function(value) {
                            if (value == "true") {
                                //console.log(value);
                                return true;
                            } else if (value == "false") {
                                //console.log(value);
                                return false;
                            } else {
                                return value;
                            }
                        };
                    }
                }
            };
        }
    };
}]);



/**
 * saCheckboxgroup指令
 * 属性如下：
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * dcvalue（必须）：绑定的model字段值，如：dcvalue={{ctrl.employeeInfoForSave.xl.id}}
 * dcname（必须）：绑定的model字段名，如：dcname=xl.id
 * name（必须）：控件的名字
 * required（可选）：是否要用required验证
 * disabled（可选）：标示框是否可选
 *
 */
angular.module('ScheduleApp').directive('saCheckboxgroup', [
    function() {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts1/checkbox/saCheckboxgroupTemplate.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型object
            },
            controllerAs: "$saCheckboxgroupCtrl",
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // 内部的数据

                // TODO：数据写死，周一至周日选择数据，以后有别的数据再议
                self.$$data = [
                    {name: "星期一", checkedvalue: "1", uncheckedvalue: "0", ischecked: false},
                    {name: "星期二", checkedvalue: "1", uncheckedvalue: "0", ischecked: false},
                    {name: "星期三", checkedvalue: "1", uncheckedvalue: "0", ischecked: false},
                    {name: "星期四", checkedvalue: "1", uncheckedvalue: "0", ischecked: false},
                    {name: "星期五", checkedvalue: "1", uncheckedvalue: "0", ischecked: false},
                    {name: "星期六", checkedvalue: "1", uncheckedvalue: "0", ischecked: false},
                    {name: "星期日", checkedvalue: "1", uncheckedvalue: "0", ischecked: false}
                ];
            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // 获取所有的属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $required_attr = tAttrs["required"]; // 是否需要required验证
                var $disabled_attr = tAttrs["disabled"]; // 是否禁用
                var $dcname_attr = tAttrs["dcname"]; // 绑定的model字段名

                // controlAs名字
                var ctrlAs = '$saCheckboxgroupCtrl';

                // 如果有required属性，添加angularjs required验证
                if ($required_attr != undefined) {
                    //console.log(tElem.html());
                    tElem.find("div").attr("required", "");
                }
                // 如果有disabled属性，添加禁用标志
                if ($disabled_attr != undefined) {
                    tElem.find("input").attr("ng-disabled", "true");
                }

                return {
                    pre: function(scope, element, attr) {
                        // TODO：
                    },
                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function(scope, element, attr) {
                        // name属性
                        if ($name_attr) {
                            scope[ctrlAs]["$name_attr"] = $name_attr;
                        }

                        /**
                         * checkbox选择事件处理函数。
                         * @param $d 数据对象，$$data中的元素对象
                         */
                        scope[ctrlAs].$$internal_updateCheck_fn = function($d) {
                            $d.ischecked = !$d.ischecked;
                            console.log($d);
                        };

                        // 测试使用watch监控$$data的变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs]["$$data"];
                            },
                            function(newValue, oldValue) {
                                // 根据$$data生成对应的数据
                                var rule_days_arr = [];
                                var i;
                                for (i = 0; i < scope[ctrlAs]["$$data"].length; i++) {
                                    if (scope[ctrlAs]["$$data"][i].ischecked)
                                        rule_days_arr.push(scope[ctrlAs]["$$data"][i].checkedvalue);
                                    else
                                        rule_days_arr.push(scope[ctrlAs]["$$data"][i].uncheckedvalue);
                                }
                                scope[ctrlAs].$$internalmodel = rule_days_arr.join(",");
                                //scope[ctrlAs].$$internalmodel = undefined;
                                console.log("bbbbbbbb--->" + scope[ctrlAs].$$internalmodel);

                                // 更新model
                                if ($dcname_attr) {
                                    eval("scope[ctrlAs].model" + "." + $dcname_attr + " = rule_days_arr.join(',');");
                                }


                            },
                            true
                        );

                        // TODO：

                        // 监控dcvalue model值变换
                        attr.$observe("dcvalue", function(value) {
                            console.log("saCheckboxgroup 监控dc1 model值变换：" + value);
                            if (value) {
                                // 根据value值，修改$$data里的值
                                var data_array = value.split(",");
                                var i;
                                if (data_array.length > scope[ctrlAs]["$$data"].length) {
                                    for (i = 0; i < scope[ctrlAs]["$$data"].length; i ++) {
                                        if (data_array[i] == scope[ctrlAs]["$$data"][i].checkedvalue) {
                                            scope[ctrlAs]["$$data"][i].ischecked = true;
                                        } else {
                                            scope[ctrlAs]["$$data"][i].ischecked = false;
                                        }
                                    }
                                } else {
                                    for (i = 0; i < data_array.length; i ++) {
                                        if (data_array[i] == scope[ctrlAs]["$$data"][i].checkedvalue) {
                                            scope[ctrlAs]["$$data"][i].ischecked = true;
                                        } else {
                                            scope[ctrlAs]["$$data"][i].ischecked = false;
                                        }
                                    }
                                }

                            }
                        });
                    }

                };


            }

        };
    }
]);




/**
 * saDategroup指令
 * 属性如下：
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * dcvalue（必须）：绑定的model字段值，如：dcvalue={{ctrl.employeeInfoForSave.xl.id}}
 * dcname（必须）：绑定的model字段名，如：dcname=xl.id
 * name（必须）：控件的名字
 * required（可选）：是否要用required验证
 * disabled（可选）：标示框是否可选
 *
 */
angular.module('ScheduleApp').directive('saDategroup', [
    '$filter',
    function($filter) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts2/dateGroup/saDategroupTemplate.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型object
            },
            controllerAs: "$saDategroupCtrl",
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // 内部的数据
                self.$$date_select; // 内部选中的日期

                //// 测试数据
                //self.$$data = [
                //    {datestr: '2011-01-01', ischecked: true},
                //    {datestr: '2011-01-01', ischecked: true},
                //    {datestr: '2011-01-01', ischecked: true}
                //];
            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // 获取所有的属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $required_attr = tAttrs["required"]; // 是否需要required验证
                var $disabled_attr = tAttrs["disabled"]; // 是否禁用
                var $dcname_attr = tAttrs["dcname"]; // 绑定的model字段名

                // controlAs名字
                var ctrlAs = '$saDategroupCtrl';

                // 如果有required属性，添加angularjs required验证
                if ($required_attr != undefined) {
                    //console.log(tElem.html());
                    tElem.find("div").attr("required", "");
                }
                // 如果有disabled属性，添加禁用标志
                if ($disabled_attr != undefined) {
                    tElem.find("input").attr("ng-disabled", "true");
                    tElem.find("div").attr("ng-disabled", "true");
                }

                return {
                    pre: function (scope, element, attr) {
                        // TODO：
                    },
                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function (scope, element, attr) {
                        // name属性
                        if ($name_attr) {
                            scope[ctrlAs]["$name_attr"] = $name_attr;
                        }


                        // 日期open属性，及方法
                        scope[ctrlAs].$$specialDateOpen = false;
                        scope[ctrlAs].$$specialDate_open = function() {
                            scope[ctrlAs].$$specialDateOpen = true;
                        };

                        // 监控选择的日期
                        scope.$watch(
                            function() {
                                return scope[ctrlAs]['$$date_select'];
                            },
                            function(newValue, oldValue) {
                                if (newValue) {
                                    //console.log("saDategroup--->selectdate：" + newValue);
                                    // 调用内置filter，转换日期到yyyy-MM-dd格式
                                    var text = $filter('date')(newValue, 'yyyy-MM-dd');
                                    var i;
                                    var isexist = false; // 日期是否已经选择标识
                                    for (i = 0; i < scope[ctrlAs]["$$data"].length; i++) {
                                        if (scope[ctrlAs]["$$data"][i].datestr == text) {
                                            isexist = true;
                                            break;
                                        }
                                    }
                                    if (!isexist) {
                                        scope[ctrlAs]["$$data"].push(
                                            {
                                                datestr: text,
                                                ischecked: true
                                            }
                                        );
                                    }

                                }

                            }
                        );

                        /**
                         * 日期点击事件处理函数。
                         * @param $index 索引
                         */
                        scope[ctrlAs].$$internal_datestr_click = function($index) {
                            scope[ctrlAs].$$data.splice($index, 1);
                        };

                        // 测试使用watch监控$$data的变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs]['$$data'];
                            },
                            function(newValue, oldValue) {
                                // 根据$$data生成对应的数据
                                var special_days_arr = [];
                                var i;
                                for (i = 0; i < scope[ctrlAs]["$$data"].length; i++) {
                                    special_days_arr.push(scope[ctrlAs]["$$data"][i].datestr);
                                }

                                scope[ctrlAs].$$internalmodel = special_days_arr.join(",");
                                console.log("bbbbbbbb--->" + scope[ctrlAs].$$internalmodel);

                                // 更新model
                                if ($dcname_attr) {
                                    eval("scope[ctrlAs].model" + "." + $dcname_attr + " = special_days_arr.join(',');");
                                }
                            },
                            true
                        );

                        // 监控dcvalue model值变换
                        attr.$observe("dcvalue", function(value) {
                            console.log("saDategroup 监控dc1 model值变换：" + value);
                            if (value) {
                                // 根据value值，修改$$data里的值
                                var date_array = value.split(",");
                                var i;
                                scope[ctrlAs]["$$data"] = [];
                                for (i = 0; i < date_array.length; i++) {
                                    scope[ctrlAs]["$$data"].push(
                                        {
                                            datestr: date_array[i],
                                            ischecked: true
                                        }
                                    );
                                }









                            }
                        });

                    }

                };
            }
        }
    }
]);




/**
 * saGuideboardgroup指令
 * 属性如下：
 * name（必须）：控件的名字
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * xlidvalue（必须）：绑定的model线路id值，如：xlidvalue={{ctrl.employeeInfoForSave.xl.id}}
 * lprangevalue（必须）：绑定的model路牌名字范围值，如：lprangevalue={{ctrl.employeeInfoForSave.lprange}}
 * lprangename（必须）：绑定的model路牌名字范围字段名，如：lprangename=lprange
 * lpidrangevalue（必须）：绑定的model路牌id范围值，如：lprangevalue={{ctrl.employeeInfoForSave.lprange}}
 * lpidrangename（必须）：绑定的model路牌id范围字段名，如：lprangename=lprange
 * lpstartvalue（必须）：绑定的model起始路牌值，如：lpstartvalue={{ctrl.employeeInfoForSave.lpstart}}
 * lpstartname（必须）：绑定的model起始路牌字段名，如：lpstartname=lpstart
 *
 * required（可选）：是否要用required验证
 *
 */
angular.module('ScheduleApp').directive('saGuideboardgroup', [
    'GuideboardManageService_g',
    function(guideboardManageService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts2/guideboardGroup/saGuideboardgroupTemplate.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型object
            },
            controllerAs: '$saGuideboardgroupCtrl',
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // 选择线路后，该线路的路牌数据

                // 测试数据
                //self.$$data = [
                //    {lpid: 1, lpname: '路1', isstart: false},
                //    {lpid: 2, lpname: '路2', isstart: true},
                //    {lpid: 3, lpname: '路3', isstart: false}
                //];


                self.$$dataSelected = []; // 选中的路牌列表
                self.$$dataSelectedStart = undefined; // 起始路牌

                //self.$$dataSelected = [
                //    {lpid: 11, lpname: '路11', isstart: false},
                //    {lpid: 12, lpname: '路12', isstart: true},
                //    {lpid: 13, lpname: '路13', isstart: false}
                //];

                // saGuideboardgroup组件的ng-model，用于外部绑定等操作
                self.$$internalmodel = undefined;

                self.$$data_init = false; // *数据源初始化标志
                self.$$data_xl_first_init = false; // 线路是否初始化
                self.$$data_lp_first_init = false; // 路牌名字是否初始化
                self.$$data_lpid_first_init = false; // 路牌id是否初始化
                self.$$data_lpstart_first_init = false; // 起始路牌是否初始化

            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // TODO：获取所有的属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $required_attr = tAttrs["required"]; // 是否需要required验证
                var $lprangename_attr = tAttrs["lprangename"]; // 绑定的model路牌名字范围字段名
                var $lpidrangename_attr = tAttrs["lpidrangename"]; // 绑定的model路牌id范围字段名
                var $lpstartname_attr = tAttrs["lpstartname"]; // 绑定的model起始路牌字段名

                // controlAs名字
                var ctrlAs = '$saGuideboardgroupCtrl';

                // 如果有required属性，添加angularjs required验证
                if ($required_attr != undefined) {
                    //console.log(tElem.html());
                    tElem.find("div").attr("required", "");
                }

                return {
                    pre: function(scope, element, attr) {
                        // TODO：
                    },

                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function(scope, element, attr) {
                        // name属性
                        if ($name_attr) {
                            scope[ctrlAs]["$name_attr"] = $name_attr;
                        }

                        // TODO：


                        /**
                         * 路牌列表点击（路牌列表中选中路牌）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_lplist_click = function($index) {
                            var data_temp = scope[ctrlAs].$$data;
                            if (data_temp && data_temp.length > $index) {
                                scope[ctrlAs].$$dataSelected.push({
                                    lpid: data_temp[$index].lpid,
                                    lpname: data_temp[$index].lpname,
                                    isstart: data_temp[$index].isstart
                                });

                                // 如果没有指定过初始路牌，默认选择此路牌作为起始路牌
                                if (scope[ctrlAs].$$dataSelectedStart == undefined) {
                                    scope[ctrlAs].$$internal_sellplist_click(
                                        scope[ctrlAs].$$dataSelected.length - 1);
                                }
                            }
                        };
                        /**
                         * 选中的路牌单击（初始路牌选择）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_sellplist_click = function($index) {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            if (data_temp && data_temp.length > $index) {
                                for (var i = 0; i < data_temp.length; i++) {
                                    data_temp[i].isstart = false;
                                }
                                data_temp[$index].isstart = true;
                                scope[ctrlAs].$$dataSelectedStart = $index;
                            }
                        };
                        /**
                         * 选中的路牌双击（删除选中的路牌）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_sellplist_dbclick = function($index) {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            if (data_temp && data_temp.length > $index) {
                                if (scope[ctrlAs].$$dataSelectedStart == $index) {
                                    scope[ctrlAs].$$dataSelectedStart = undefined;
                                }
                                data_temp.splice($index, 1);
                            }
                        };


                        /**
                         * 验证内部数据，更新外部model
                         */
                        scope[ctrlAs].$$internal_validate_model = function() {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            var data_temp2 = scope[ctrlAs].$$dataSelectedStart;
                            var lpNames = [];
                            var lpIds = [];
                            var lpStart = 0;
                            var i = 0;

                            if (data_temp &&
                                data_temp.length > 0 &&
                                data_temp2 != undefined) {

                                for (i = 0; i < data_temp.length; i++) {
                                    lpNames.push(data_temp[i].lpname);
                                    lpIds.push(data_temp[i].lpid)
                                }
                                data_temp[data_temp2].isstart = true;
                                lpStart = data_temp2 + 1;

                                // 更新内部model，用于外部验证
                                // 内部model的值暂时随意，以后再改
                                scope[ctrlAs].$$internalmodel = {desc: "ok"};

                                // 更新外部model字段
                                if ($lprangename_attr) {
                                    console.log("lprangename=" + lpNames.join(','));
                                    eval("scope[ctrlAs].model" + "." + $lprangename_attr + " = lpNames.join(',');");
                                }
                                if ($lpidrangename_attr) {
                                    console.log("lpidrangename=" + lpIds.join(','));
                                    eval("scope[ctrlAs].model" + "." + $lpidrangename_attr + " = lpIds.join(',');");
                                }
                                if ($lpstartname_attr) {
                                    console.log("lpstartname=" + lpStart);
                                    eval("scope[ctrlAs].model" + "." + $lpstartname_attr + " = lpStart;");
                                }

                            } else {
                                scope[ctrlAs].$$internalmodel = undefined;
                            }


                        };

                        // 监控内部数据，$$data_selected 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$dataSelected;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        // 监控内部数据，$$data_selected_start 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$dataSelectedStart;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        /**
                         * 验证数据是否初始化完成，
                         * 所谓的初始化就是内部所有的数据被有效设定过一次。
                         */
                        scope[ctrlAs].$$internal_validate_init = function() {
                            var self = scope[ctrlAs];

                            if (self.$$data_xl_first_init &&
                                self.$$data_lp_first_init &&
                                self.$$data_lpid_first_init &&
                                self.$$data_lpstart_first_init) {
                                console.log("数据初始化完毕！");
                                self.$$data_init = true;
                            }

                        };

                        // 监控初始化标志，线路，路牌，路牌id，起始路牌
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_xl_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_lp_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_lpid_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_lpstart_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );


                        // 监控线路id的变化
                        attr.$observe("xlidvalue", function(value) {
                            if (value && value != "") {
                                console.log("xlidvalue=" + value);

                                guideboardManageService_g.rest.list(
                                    {"xl.id_eq": value, size: 100},
                                    function(result) {
                                        // 获取值了
                                        console.log("路牌获取了");

                                        scope[ctrlAs].$$data = [];
                                        for (var i = 0; i < result.content.length; i++) {
                                            scope[ctrlAs].$$data.push({
                                                lpid: result.content[i].id,
                                                lpname: result.content[i].lpName,
                                                isstart: false
                                            });
                                        }
                                        if (scope[ctrlAs].$$data_init) {
                                            scope[ctrlAs].$$dataSelected = [];
                                            scope[ctrlAs].$$dataSelectedStart = undefined;
                                            scope[ctrlAs].$$internalmodel = undefined;
                                        }
                                        scope[ctrlAs].$$data_xl_first_init = true;
                                    },
                                    function(result) {

                                    }
                                );

                            }
                        });

                        // 监控路牌名称范围值的变化
                        attr.$observe("lprangevalue", function(value) {
                            if (value && value != "") {
                                var data_temp = scope[ctrlAs].$$dataSelected;
                                var lpnames = value.split(",");
                                var i = 0;
                                if (data_temp && data_temp.length == 0) { // 初始创建
                                    console.log("lprangevalue变换了");
                                    for (i = 0; i < lpnames.length; i++) {
                                        scope[ctrlAs].$$dataSelected.push({
                                            lpname: lpnames[i],
                                            isstart: false
                                        });
                                    }
                                } else {
                                    for (i = 0; i < lpnames.length; i++) {
                                        data_temp[i].lpname = lpnames[i];
                                    }
                                }
                                scope[ctrlAs].$$data_lp_first_init = true;
                            }
                        });

                        // 监控路牌id范围值的变化
                        attr.$observe("lpidrangevalue", function(value) {
                            if (value && value != "") {
                                console.log("lpidrangevalue=" + value);
                                var data_temp = scope[ctrlAs].$$dataSelected;
                                var lpids = value.split(",");
                                var i = 0;
                                if (data_temp && data_temp.length == 0) { // 初始创建
                                    console.log("lpidrangevalue");
                                    for (i = 0; i < lpids.length; i++) {
                                        scope[ctrlAs].$$dataSelected.push({
                                            lpid: lpids[i],
                                            isstart: false
                                        });
                                    }
                                } else {
                                    for (i = 0; i < lpids.length; i++) {
                                        data_temp[i].lpid = lpids[i];
                                    }
                                }
                                scope[ctrlAs].$$data_lpid_first_init = true;
                            }
                        });

                        // 监控起始路牌的变化
                        attr.$observe("lpstartvalue", function(value) {
                            if (value && value != "") {
                                scope[ctrlAs].$$dataSelectedStart = value - 1;
                                scope[ctrlAs].$$data_lpstart_first_init = true;
                            }
                        });



                    }
                }

            }
        }
    }
]);




/**
 * saEmployeegroup指令
 * 属性如下：
 * name（必须）：控件的名字
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * xlidvalue（必须）：绑定的model线路id值，如：xlidvalue={{ctrl.employeeInfoForSave.xl.id}}
 * dbbmrangevalue（必须）：绑定的model搭班编码范围值，如：lprangevalue={{ctrl.employeeInfoForSave.lprange}}
 * dbbmrangename（必须）：绑定的model搭班编码范围字段名，如：lprangename=lprange
 * rycidrangevalue（必须）：绑定的model人员配置idid范围值，如：lprangevalue={{ctrl.employeeInfoForSave.lprange}}
 * rycidrangename（必须）：绑定的model人员配置id范围字段名，如：lprangename=lprange
 * rystartvalue（必须）：绑定的model起始人员，如：lpstartvalue={{ctrl.employeeInfoForSave.lpstart}}
 * rystartname（必须）：绑定的model起始人员字段名，如：lpstartname=lpstart
 *
 * required（可选）：是否要用required验证
 *
 */
angular.module('ScheduleApp').directive('saEmployeegroup', [
    'EmployeeConfigService_g',
    function(employeeConfigService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts2/employeeGroup/saEmployeegroupTemplate.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型object
            },
            controllerAs: '$saEmployeegroupCtrl',
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // 选择线路后，该线路的人员配置数据

                // 测试数据
                //self.$$data = [
                //    {id: 1, dbbm: "1", jsy: '忍1', spy: '守1'},
                //    {id: 2, dbbm: "2", jsy: '忍2', spy: '守2'},
                //    {id: 3, dbbm: "3", jsy: '忍3', spy: '守3'}
                //];

                self.$$dataSelected = []; // 选中的人员配置列表
                self.$$dataSelectedStart = undefined; // 起始人员配置

                //self.$$dataSelected = [
                //    {id: 1, dbbm: "1", jsy: '忍1', spy: '守1', isstart: false},
                //    {id: 2, dbbm: "2", jsy: '忍2', spy: '守2', isstart: true},
                //    {id: 3, dbbm: "3", jsy: '忍3', spy: '守3', isstart: false}
                //];

                self.$$isFB = false; // 是否分班
                self.$$dataFBSelected = []; // 选中的分班人员组配置列表
                self.$$dataFBInternalSelected = undefined; // 分班组内人员选中标识
                self.$$dataFBSelectedStart = undefined; // 选中的起始分班人员组合

                //self.$$dataFBSelected = [
                //    {isstart: true, group: [
                //        {id: 1, dbbm: "1", jsy: '忍1', spy: '守1', isselected: false},
                //        {id: 2, dbbm: "2", jsy: '忍2', spy: '守2', isstart: true}
                //    ]},
                //    {isstart: false, group: [
                //        {id: 1, dbbm: "1", jsy: '忍1', spy: '守1', isselected: false},
                //        {id: 2, dbbm: "2", jsy: '忍2', spy: '守2', isstart: true}
                //    ]}
                //];

                // saGuideboardgroup组件的ng-model，用于外部绑定等操作
                self.$$internalmodel = undefined;

                self.$$data_init = false; // *数据源初始化标志
                self.$$data_xl_first_init = false; // 线路是否初始化
                self.$$data_ry_first_init = false; // 人员配置是否初始化
                self.$$data_ry_first_data = undefined; // 人员配置初始化数据
                self.$$data_rycid_first_init = false; // 人员配置id是否初始化
                self.$$data_rycid_first_data = undefined; // 人员配置id初始化数据
                self.$$data_rystart_first_init = false; // 起始人员是否初始化
                self.$$data_rystart_first_data = undefined; // 起始人员初始化数据

            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // TODO：获取所有的属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $required_attr = tAttrs["required"]; // 是否需要required验证
                var $dbbmrangename_attr = tAttrs["dbbmrangename"]; // 绑定的model搭班编码范围字段名
                var rycidrangename_attr = tAttrs["rycidrangename"]; // 绑定的model人员配置id范围字段名
                var $rystartname_attr = tAttrs["rystartname"]; // 绑定的model起始人员字段名

                // controlAs名字
                var ctrlAs = '$saEmployeegroupCtrl';

                // 如果有required属性，添加angularjs required验证
                if ($required_attr != undefined) {
                    //console.log(tElem.html());
                    tElem.find("div").attr("required", "");
                }

                return {
                    pre: function(scope, element, attr) {
                        // TODO：
                    },

                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function(scope, element, attr) {
                        // name属性
                        if ($name_attr) {
                            scope[ctrlAs]["$name_attr"] = $name_attr;
                        }

                        /**
                         * 人员配置列表点击（人员配置列表中选中路牌）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_rylist_click = function($index) {
                            var data_temp = scope[ctrlAs].$$data;
                            if (data_temp && data_temp.length > $index) {
                                if (!scope[ctrlAs].$$isFB) { // 不分班
                                    scope[ctrlAs].$$dataSelected.push({
                                        id : data_temp[$index].id,
                                        dbbm: data_temp[$index].dbbm,
                                        jsy: data_temp[$index].jsy,
                                        spy: data_temp[$index].spy,
                                        isstart: false
                                    });

                                    // 如果没有指定过初始人员，默认选择此人员作为起始人员
                                    if (scope[ctrlAs].$$dataSelectedStart == undefined) {
                                        scope[ctrlAs].$$internal_selrylist_click(
                                            scope[ctrlAs].$$dataSelected.length - 1);
                                    }
                                } else { // 分班
                                    if (scope[ctrlAs].$$dataFBInternalSelected) { // 替换组内人员
                                        scope[ctrlAs].$$dataFBSelected
                                            [scope[ctrlAs].$$dataFBInternalSelected.gindex].group
                                            [scope[ctrlAs].$$dataFBInternalSelected.index] = {
                                            id : data_temp[$index].id,
                                            dbbm: data_temp[$index].dbbm,
                                            jsy: data_temp[$index].jsy,
                                            spy: data_temp[$index].spy,
                                            isselected: true
                                        };

                                    } else {
                                        scope[ctrlAs].$$dataFBSelected.push({
                                            isstart: false,
                                            group: [].concat(
                                                {
                                                    id : data_temp[$index].id,
                                                    dbbm: data_temp[$index].dbbm,
                                                    jsy: data_temp[$index].jsy,
                                                    spy: data_temp[$index].spy,
                                                    isselected: false
                                                }, {
                                                    id : data_temp[$index].id,
                                                    dbbm: data_temp[$index].dbbm,
                                                    jsy: data_temp[$index].jsy,
                                                    spy: data_temp[$index].spy,
                                                    isselected: false
                                                }
                                            )
                                        });
                                        if (scope[ctrlAs].$$dataFBSelectedStart == undefined) {
                                            scope[ctrlAs].$$internal_selrygrouplist_click(
                                                scope[ctrlAs].$$dataFBSelected.length - 1);
                                        }
                                    }
                                }

                            }
                        };

                        /**
                         * 选中的人员单击（初始人员选择）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_selrylist_click = function($index) {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            if (data_temp && data_temp.length > $index) {
                                for (var i = 0; i < data_temp.length; i++) {
                                    data_temp[i].isstart = false;
                                }
                                data_temp[$index].isstart = true;
                                scope[ctrlAs].$$dataSelectedStart = $index;
                            }
                        };
                        /**
                         * 选中的人员双击（删除选中的人员）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_selrylist_dbclick = function($index) {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            if (data_temp && data_temp.length > $index) {
                                if (scope[ctrlAs].$$dataSelectedStart == $index) {
                                    scope[ctrlAs].$$dataSelectedStart = undefined;
                                }
                                data_temp.splice($index, 1);
                            }
                        };

                        /**
                         * 选中的分班组人员单击（初始人员选择）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_selrygrouplist_click = function($index) {
                            var data_temp = scope[ctrlAs].$$dataFBSelected;
                            if (data_temp && data_temp.length > $index) {
                                for (var i = 0; i < data_temp.length; i++) {
                                    data_temp[i].isstart = false;
                                    for (var j = 0; j < data_temp[i].group.length; j++) {
                                        data_temp[i].group[j].isselected = false;
                                    }
                                }
                                data_temp[$index].isstart = true;
                                scope[ctrlAs].$$dataFBSelectedStart = $index;
                                scope[ctrlAs].$$dataFBInternalSelected = undefined;
                            }
                        };
                        /**
                         * 分组内部单击（选中分班中的某组人员）
                         * @param $groupindex 组index
                         * @param $index 组内部某个index
                         * @param $event 事件防止冒泡
                         */
                        scope[ctrlAs].$$internal_selrygroup_click = function($groupindex, $index, $event) {
                            var data_temp = scope[ctrlAs].$$dataFBSelected;
                            if (data_temp && data_temp.length > $groupindex) {
                                if (data_temp[$groupindex].group && data_temp[$groupindex].group.length > $index) {
                                    // $$dataFBInternalSelected的格式如下：
                                    //{gindex: 1, index: 0}
                                    for (var i = 0; i < data_temp.length; i++) {
                                        data_temp[i].isstart = false;
                                        for (var j = 0; j < data_temp[i].group.length; j++) {
                                            data_temp[i].group[j].isselected = false;
                                        }
                                    }
                                    data_temp[$groupindex].group[$index].isselected = true;
                                    scope[ctrlAs].$$dataFBInternalSelected = {
                                        gindex: $groupindex, index: $index
                                    };
                                    scope[ctrlAs].$$dataFBSelectedStart = undefined;
                                    $event.stopPropagation();
                                }
                            }

                        };
                        /**
                         * 选中的分班人员双击（删除选中的人员）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_selrygrouplist_dbclick = function($index) {
                            var data_temp = scope[ctrlAs].$$dataFBSelected;
                            if (data_temp && data_temp.length > $index) {
                                if (scope[ctrlAs].$$dataFBSelectedStart == $index) {
                                    scope[ctrlAs].$$dataFBSelectedStart = undefined;
                                }
                                if (scope[ctrlAs].$$dataFBInternalSelected &&
                                    scope[ctrlAs].$$dataFBInternalSelected.gindex == $index) {
                                    scope[ctrlAs].$$dataFBInternalSelected = undefined;
                                }
                                data_temp.splice($index, 1);
                            }
                        };

                        /**
                         * 验证内部数据，更新外部model
                         */
                        scope[ctrlAs].$$internal_validate_model = function() {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            var data_temp2 = scope[ctrlAs].$$dataSelectedStart;
                            var data_temp3 = scope[ctrlAs].$$dataFBSelected;
                            var data_temp4 = scope[ctrlAs].$$dataFBSelectedStart;
                            var ryDbbms = [];
                            var ryDbbm_group = [];
                            var ryCids = [];
                            var ryCid_group = [];
                            var ryStart = 0;
                            var i = 0;
                            var j = 0;

                            var isFB = scope[ctrlAs].$$isFB;

                            if (isFB) {
                                if (data_temp3 &&
                                    data_temp3.length > 0 &&
                                    data_temp4 != undefined) {

                                    for (i = 0; i < data_temp3.length; i++) {
                                        for (j = 0; j < data_temp3[i].group.length; j++) {
                                            ryDbbm_group.push(data_temp3[i].group[j].dbbm);
                                            ryCid_group.push(data_temp3[i].group[j].id);
                                        }
                                        ryDbbms.push(ryDbbm_group.join("-"));
                                        ryCids.push(ryCid_group.join("-"));
                                        ryDbbm_group = [];
                                        ryCid_group = [];
                                    }

                                    data_temp3[data_temp4].isstart = true;
                                    ryStart = data_temp4 + 1;

                                    // 更新内部model，用于外部验证
                                    // 内部model的值暂时随意，以后再改
                                    scope[ctrlAs].$$internalmodel = {desc: "ok"};

                                    // 更新外部model字段
                                    if ($dbbmrangename_attr) {
                                        console.log("dbbmrangename=" + ryDbbms.join(','));
                                        eval("scope[ctrlAs].model" + "." + $dbbmrangename_attr + " = ryDbbms.join(',');");
                                    }
                                    if (rycidrangename_attr) {
                                        console.log("rycidrangename=" + ryCids.join(','));
                                        eval("scope[ctrlAs].model" + "." + rycidrangename_attr + " = ryCids.join(',');");
                                    }
                                    if ($rystartname_attr) {
                                        console.log("rystartname=" + ryStart);
                                        eval("scope[ctrlAs].model" + "." + $rystartname_attr + " = ryStart;");
                                    }

                                } else {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                }

                            } else {
                                if (data_temp &&
                                    data_temp.length > 0 &&
                                    data_temp2 != undefined) {

                                    for (i = 0; i < data_temp.length; i++) {
                                        ryDbbms.push(data_temp[i].dbbm);
                                        ryCids.push(data_temp[i].id);
                                    }
                                    data_temp[data_temp2].isstart = true;
                                    ryStart = data_temp2 + 1;

                                    // 更新内部model，用于外部验证
                                    // 内部model的值暂时随意，以后再改
                                    scope[ctrlAs].$$internalmodel = {desc: "ok"};

                                    // 更新外部model字段
                                    if ($dbbmrangename_attr) {
                                        console.log("dbbmrangename=" + ryDbbms.join(','));
                                        eval("scope[ctrlAs].model" + "." + $dbbmrangename_attr + " = ryDbbms.join(',');");
                                    }
                                    if (rycidrangename_attr) {
                                        console.log("rycidrangename=" + ryCids.join(','));
                                        eval("scope[ctrlAs].model" + "." + rycidrangename_attr + " = ryCids.join(',');");
                                    }
                                    if ($rystartname_attr) {
                                        console.log("rystartname=" + ryStart);
                                        eval("scope[ctrlAs].model" + "." + $rystartname_attr + " = ryStart;");
                                    }

                                } else {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                }
                            }

                        };

                        // 监控内部数据，$$dataSelected 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$dataSelected;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        // 监控内部数据，$$dataSelectedStart 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$dataSelectedStart;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );


                        // 监控内部数据，$$dataFBSelected 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$dataFBSelected;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        // 监控内部数据，$$dataFBSelectedStart 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$dataFBSelectedStart;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        // 监控内部数据，$$dataFBInternalSelected 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$dataFBInternalSelected;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        // 监控内部数据，$$isFB 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$isFB;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        /**
                         * 验证数据是否初始化完成，
                         * 所谓的初始化就是内部所有的数据被有效设定过一次。
                         */
                        scope[ctrlAs].$$internal_validate_init = function() {
                            var self = scope[ctrlAs];
                            var data_temp = self.$$data;
                            var dataSelect_temp = self.$$dataSelected;
                            var dataFBSelect_temp = self.$$dataFBSelected;
                            var dbbmnames = null;
                            var dbbmnamegroup = null;
                            var rycids = null;
                            var rycidgroup = null;

                            var i = 0;
                            var j = 0;
                            var k = 0;

                            if (self.$$data_xl_first_init &&
                                self.$$data_ry_first_init &&
                                self.$$data_rycid_first_init &&
                                self.$$data_rystart_first_init && !self.$$data_init) {
                                console.log("开始初始化数据");

                                // 判定是否分班，字符串中包含-就是了
                                if (self.$$data_ry_first_data.indexOf("-") != -1 && dataFBSelect_temp.length == 0) { // 分班
                                    self.$$isFB = true;

                                    // 搭班编码、人员配置id
                                    dbbmnames = self.$$data_ry_first_data.split(",");
                                    rycids = self.$$data_rycid_first_data.split(",");
                                    for (i = 0; i < dbbmnames.length; i++) {
                                        dataFBSelect_temp.push({
                                            group: [],
                                            isstart: false
                                        });
                                        dbbmnamegroup = dbbmnames[i].split("-");
                                        rycidgroup = rycids[i].split("-");

                                        for (k = 0; k < dbbmnamegroup.length; k++) {
                                            dataFBSelect_temp[i].group.push({
                                                id: rycidgroup[k],
                                                dbbm: dbbmnamegroup[k],
                                                isselected: false
                                            });

                                            for (j = 0; j < data_temp.length; j++) {
                                                if (dataFBSelect_temp[i].group[k].dbbm == data_temp[j].dbbm) {
                                                    dataFBSelect_temp[i].group[k].jsy = data_temp[j].jsy;
                                                    dataFBSelect_temp[i].group[k].spy = data_temp[j].spy;
                                                    break;
                                                }
                                            }
                                        }

                                    }

                                    // 初始人员
                                    scope[ctrlAs].$$dataFBSelectedStart = self.$$data_rystart_first_data - 1;


                                } else if (dataSelect_temp.length == 0) {
                                    self.$$isFB = false;

                                    // 搭班编码、人员配置id
                                    dbbmnames = self.$$data_ry_first_data.split(",");
                                    rycids = self.$$data_rycid_first_data.split(",");
                                    for (i = 0; i < dbbmnames.length; i++) {
                                        dataSelect_temp.push({
                                            id: rycids[i],
                                            dbbm: dbbmnames[i],
                                            isstart: false
                                        });
                                        for (j = 0; j < data_temp.length; j++) {
                                            if (dataSelect_temp[i].dbbm == data_temp[j].dbbm) {
                                                dataSelect_temp[i].jsy = data_temp[j].jsy;
                                                dataSelect_temp[i].spy = data_temp[j].spy;
                                                break;
                                            }
                                        }
                                    }
                                    // 初始人员
                                    scope[ctrlAs].$$dataSelectedStart = self.$$data_rystart_first_data - 1;

                                }

                                console.log("数据初始化完毕！");
                                self.$$data_init = true;
                            }

                        };

                        // 监控初始化标志，线路，人员，起始人员
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_xl_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_ry_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_rycid_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_rystart_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );


                        // 监控线路id的变化
                        attr.$observe("xlidvalue", function(value) {
                            if (value && value != "") {
                                console.log("xlidvalue=" + value);

                                employeeConfigService_g.rest.list(
                                    {"xl.id_eq": value, "isCancel_eq" : false, size: 100},
                                    function(result) {
                                        // 获取值了
                                        console.log("人员配置获取了");

                                        scope[ctrlAs].$$data = [];
                                        for (var i = 0; i < result.content.length; i++) {
                                            scope[ctrlAs].$$data.push({
                                                id: result.content[i].id,
                                                dbbm: result.content[i].dbbm,
                                                jsy: result.content[i].jsy.personnelName,
                                                spy: result.content[i].spy == null ? "" : result.content[i].spy.personnelName
                                            });
                                        }
                                        if (scope[ctrlAs].$$data_init) {
                                            scope[ctrlAs].$$dataSelected = [];
                                            scope[ctrlAs].$$dataSelectedStart = undefined;

                                            scope[ctrlAs].$$dataFBSelected = [];
                                            scope[ctrlAs].$$dataFBInternalSelected = undefined;
                                            scope[ctrlAs].$$dataFBSelectedStart = undefined;

                                            scope[ctrlAs].$$internalmodel = undefined;
                                        }
                                        scope[ctrlAs].$$data_xl_first_init = true;
                                    },
                                    function(result) {

                                    }
                                );

                            }
                        });

                        // 监控搭班编码范围值的变化
                        attr.$observe("dbbmrangevalue", function(value) {
                            if (value && value != "") {
                                console.log("dbbmrangevalue变换了");
                                scope[ctrlAs].$$data_ry_first_init = true;
                                scope[ctrlAs].$$data_ry_first_data = value;
                            }
                        });

                        // 监控人员配置id范围值的变化
                        attr.$observe("rycidrangevalue", function(value) {
                            if (value && value != "") {
                                console.log("rycidrangevalue变换了");
                                scope[ctrlAs].$$data_rycid_first_init = true;
                                scope[ctrlAs].$$data_rycid_first_data = value;
                            }
                        });

                        // 监控起始人员的变化
                        attr.$observe("rystartvalue", function(value) {
                            if (value && value != "") {
                                console.log("rystartvalue变换了");
                                scope[ctrlAs].$$data_rystart_first_init = true;
                                scope[ctrlAs].$$data_rystart_first_data = value;
                            }
                        });

                    }
                }

            }
        }
    }
]);


/**
 * saBcgroup指令，用于套跑界面中，从指定线路，指定时刻表，指定路牌的班次列表中选择套跑班次。
 * 属性如下：
 * name（必须）：控件的名字
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * bcttinfoidsvalue（必须）：绑定的model班次ids字段值，如：bcttinfoidsvalue={{ctrl.employeeInfoForSave.lprange}}
 * bcttinfoidsname（必须）：bind的model班次ids字段名，如：bcttinfoidsname=lprange
 * dataparams (必须)：内部数据关联的查询参数，如：{{ {'ttid': ctrl.rerunManageForSave.rerunTtinfo.id} | json }}
 * required（可选）：是否要用required验证
 *
 */
angular.module('ScheduleApp').directive('saBcgroup', [
    'TimeTableDetailManageService_g',
    function(timeTableDetailManageService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/common/dts2/bcGroup/saBcgroupTemplate.html',
            scope: {
                model: "=" // 独立作用域，关联外部的模型object
            },
            controllerAs: '$saBcgroupCtrl',
            bindToController: true,
            controller: function($scope) {
                var self = this;
                self.$$data = []; // 选择线路，时刻表，路牌后的班次列表

                // 测试数据
                //self.$$data = [
                //    {bcttinfoid: 1, bcfcsj: '7:30', bctype: 'out'},
                //    {bcttinfoid: 2, bcfcsj: '8:30', bctype: 'normal'},
                //    {bcttinfoid: 3, bcfcsj: '9:30', bctype: 'in'}
                //];


                self.$$dataSelected = []; // 套跑选中的班次列表

                //self.$$dataSelected = [
                //    {bcttinfoid: 1, bcfcsj: '7:30', bctype: 'out'},
                //    {bcttinfoid: 2, bcfcsj: '8:30', bctype: 'normal'},
                //    {bcttinfoid: 3, bcfcsj: '9:30', bctype: 'in'}
                //];

                // saBcgroup组件的ng-model，用于外部绑定等操作
                self.$$internalmodel = undefined;

                self.$$data_bcdata_first_init = false; // 班次数据首次初始化标志
                self.$$data_bcttinfoids_first_init = false; // 班次ids数据首次初始化标志
                self.$$data_bcttinfoids_first_data = undefined; // 班次ids数据首次初始化数据

            },

            /**
             * 此阶段可以改dom结构，此时angular还没扫描指令，
             * 这里就可以动态添加其他angularjs的指令字符串，如required指令字符串。
             * @param tElem
             * @param tAttrs
             * @returns {{pre: Function, post: Function}}
             */
            compile: function(tElem, tAttrs) {
                // TODO：获取所有的属性
                var $name_attr = tAttrs["name"]; // 控件的名字
                var $required_attr = tAttrs["required"]; // 是否需要required验证
                var $bcttinfoidsname_attr = tAttrs["bcttinfoidsname"]; // bind的model班次ids字段名

                // controlAs名字
                var ctrlAs = '$saBcgroupCtrl';

                // 如果有required属性，添加angularjs required验证
                if ($required_attr != undefined) {
                    //console.log(tElem.html());
                    tElem.find("div").attr("required", "");
                }

                return {
                    pre: function(scope, element, attr) {
                        // TODO：
                    },

                    /**
                     * 相当于link函数。
                     * @param scope
                     * @param element
                     * @param attr
                     */
                    post: function(scope, element, attr) {
                        // name属性
                        if ($name_attr) {
                            scope[ctrlAs]["$name_attr"] = $name_attr;
                        }

                        // TODO：


                        /**
                         * 班次列表点击（班次列表中选中班次）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_bclist_click = function($index) {
                            var data_temp = scope[ctrlAs].$$data;
                            var data_temp2 = scope[ctrlAs].$$dataSelected;
                            var i = 0;
                            var isunique = true; // 是否已经选择过
                            if (data_temp && data_temp.length > $index) {
                                for (i = 0; i < data_temp2.length; i++) {
                                    if (data_temp2[i].bcttinfoid == data_temp[$index].bcttinfoid) {
                                        isunique = false;
                                        break;
                                    }
                                }
                                if (isunique) {
                                    data_temp2.push({
                                        bcttinfoid: data_temp[$index].bcttinfoid,
                                        bcfcsj: data_temp[$index].bcfcsj,
                                        bctype: data_temp[$index].bctype
                                    });
                                }

                            }
                        };
                        /**
                         * 选中的班次双击（删除选中的班次）
                         * @param $index
                         */
                        scope[ctrlAs].$$internal_selbclist_dbclick = function($index) {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            if (data_temp && data_temp.length > $index) {
                                data_temp.splice($index, 1);
                            }
                        };


                        /**
                         * 验证内部数据，更新外部model
                         */
                        scope[ctrlAs].$$internal_validate_model = function() {
                            var data_temp = scope[ctrlAs].$$dataSelected;
                            var bcttinfoIds = [];
                            var i = 0;

                            if (data_temp &&
                                data_temp.length > 0) {

                                for (i = 0; i < data_temp.length; i++) {
                                    bcttinfoIds.push(data_temp[i].bcttinfoid);
                                }

                                // 更新外部model字段
                                if ($bcttinfoidsname_attr) {
                                    console.log("bcttinfoidsname=" + bcttinfoIds.join(','));
                                    eval("scope[ctrlAs].model" + "." + $bcttinfoidsname_attr + " = bcttinfoIds.join(',');");
                                }

                                // 更新内部model，用于外部验证
                                // 内部model的值暂时随意，以后再改
                                scope[ctrlAs].$$internalmodel = {desc: "ok"};

                                scope[ctrlAs].$$data_bcdata_first_init = true;
                                scope[ctrlAs].$$data_bcttinfoids_first_init = true;

                            } else {
                                scope[ctrlAs].$$internalmodel = undefined;
                            }

                        };

                        // 监控内部数据，$$data_selected 变化
                        scope.$watch(
                            function() {
                                console.log("长度：" + scope[ctrlAs].$$dataSelected.length);
                                return scope[ctrlAs].$$dataSelected;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_model();
                            },
                            true
                        );

                        /**
                         * 验证数据是否初始化完成，
                         * 所谓的初始化就是内部所有的数据被有效设定过一次。
                         */
                        scope[ctrlAs].$$internal_validate_init = function() {
                            var self = scope[ctrlAs];

                            var data_temp = self.$$data;
                            var dataSelect_temp = self.$$dataSelected;
                            var bcttinfoids = null;

                            var i = 0;
                            var j = 0;

                            if (self.$$data_bcdata_first_init &&
                                self.$$data_bcttinfoids_first_init) {
                                console.log("开始初始化数据");

                                bcttinfoids = self.$$data_bcttinfoids_first_data ? self.$$data_bcttinfoids_first_data.split(",") : [];

                                for (i = 0; i < bcttinfoids.length; i++) {
                                    dataSelect_temp.push({
                                        bcttinfoid: bcttinfoids[i]
                                    });
                                    for (j = 0; j < data_temp.length; j++) {
                                        if (dataSelect_temp[i].bcttinfoid == data_temp[j].bcttinfoid) {
                                            dataSelect_temp[i].bcfcsj = data_temp[j].bcfcsj;
                                            dataSelect_temp[i].bctype = data_temp[j].bctype;
                                            break;
                                        }
                                    }
                                }

                                console.log("数据初始化完毕！");
                            }

                        };

                        // 监控初始化标志
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_bcdata_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$data_bcttinfoids_first_init;
                            },
                            function(newValue, oldValue) {
                                scope[ctrlAs].$$internal_validate_init();
                            }
                        );

                        // 监控内部数据的变化
                        attr.$observe("dataparams", function(value) {
                            if (value && value != "") {
                                if (value == '{}') {
                                    return;
                                }

                                console.log("bcgroup observe 监控 dataparams=" + value);

                                timeTableDetailManageService_g.bcdetails.list(
                                    JSON.parse(value),
                                    function(result) {
                                        // 获取值了
                                        console.log("内部班次数据获取了");

                                        scope[ctrlAs].$$data = [];
                                        for (var i = 0; i < result.length; i++) {
                                            scope[ctrlAs].$$data.push({
                                                bcttinfoid: result[i].id,
                                                bcfcsj: result[i].fcsj,
                                                bctype: result[i].bcType
                                            });
                                        }
                                        if (scope[ctrlAs].$$data_bcdata_first_init &&
                                            scope[ctrlAs].$$data_bcttinfoids_first_init) {

                                            scope[ctrlAs].$$dataSelected = [];
                                            scope[ctrlAs].$$internalmodel = undefined;
                                        }
                                        scope[ctrlAs].$$data_bcdata_first_init = true;
                                    },
                                    function(result) {

                                    }
                                );
                            }
                        });
                        // 监控班次ids数据的变化
                        attr.$observe("bcttinfoidsvalue", function(value) {
                            if (value && value != "") {
                                console.log("observe 监控 bcttinfoidsvalue=" + value);
                                scope[ctrlAs].$$data_bcttinfoids_first_init = true;
                                scope[ctrlAs].$$data_bcttinfoids_first_data = value;
                            }
                        });

                    }
                }

            }
        }
    }
]);