潘钊 / bsth_control · Files

// 自定义指令，指令模版在dt目录下


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();
            });
        }
    };
}]);

angular.module('ScheduleApp').directive("saSelect", ['$timeout', function($timeout) {
    return {
        restrict: 'E',
        templateUrl: '/pages/scheduleApp/module/other/MyDictionarySelectTemplate.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);
                }
            }
        }
    };
}]);

/**
 * 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/dt/MyRadioGroupWrapTemplate.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;
                            }
                        };
                    }
                }
            };
        }
    };
}]);

angular.module('ScheduleApp').directive("remoteValidaton", [
    'BusInfoManageService_g',
    'EmployeeInfoManageService_g',
    'TimeTableManageService_g',
    function(
        busInfoManageService_g,
        employeeInfoManageService_g,
        timeTableManageService_g
    ) {
        /**
         * 远端验证指令，依赖于ngModel
         * 指令名称 remote-Validation
         * 需要属性 rvtype 表示验证类型
         */
        return {
            restrict: "A",
            require: "^ngModel",
            link: function(scope, element, attr, ngModelCtrl) {
                element.bind("keyup", function() {
                    var modelValue = ngModelCtrl.$modelValue;
                    var rv1_attr = attr["rv1"];
                    if (attr["rvtype"]) {

                        // 根据rvtype的值，确定使用那个远端验证的url，
                        // rv1, rv2, rv3是关联比较值，暂时使用rv1
                        // 这个貌似没法通用，根据业务变换
                        // TODO：暂时有点乱以后改
                        if (attr["rvtype"] == "insideCode") {
                            busInfoManageService_g.validate.insideCode(
                                {"insideCode_eq": modelValue, type: "equale"},
                                function(result) {
                                    //console.log(result);
                                    if (result.status == "SUCCESS") {
                                        ngModelCtrl.$setValidity('remote', true);
                                    } else {
                                        ngModelCtrl.$setValidity('remote', false);
                                    }
                                },
                                function(result) {
                                    //console.log(result);
                                    ngModelCtrl.$setValidity('remote', true);
                                }
                            );
                        } else if (attr["rvtype"] == "jobCode") {
                            if (!rv1_attr) {
                                ngModelCtrl.$setValidity('remote', false);
                                return;
                            }

                            employeeInfoManageService_g.validate.jobCode(
                                {"jobCode_eq": modelValue, "companyCode_eq": rv1_attr, type: "equale"},
                                function(result) {
                                    //console.log(result);
                                    if (result.status == "SUCCESS") {
                                        ngModelCtrl.$setValidity('remote', true);
                                    } else {
                                        ngModelCtrl.$setValidity('remote', false);
                                    }
                                },
                                function(result) {
                                    //console.log(result);
                                    ngModelCtrl.$setValidity('remote', true);
                                }
                            );
                        } else if (attr["rvtype"] == "ttinfoname") {
                            if (!rv1_attr) {
                                ngModelCtrl.$setValidity('remote', false);
                                return;
                            }

                            timeTableManageService_g.validate.ttinfoname(
                                {"name_eq": modelValue, "xl.id_eq": rv1_attr, type: "equale"},
                                function(result) {
                                    //console.log(result);
                                    if (result.status == "SUCCESS") {
                                        ngModelCtrl.$setValidity('remote', true);
                                    } else {
                                        ngModelCtrl.$setValidity('remote', false);
                                    }
                                },
                                function(result) {
                                    //console.log(result);
                                    ngModelCtrl.$setValidity('remote', true);
                                }
                            );

                        }
                    } else {
                        // 没有rvtype，就不用远端验证了
                        ngModelCtrl.$setValidity('remote', true);
                    }

                    attr.$observe("rv1", function(value) {
                        if (attr["rvtype"] == "jobCode") {
                            if (!value) {
                                ngModelCtrl.$setValidity('remote', false);
                                return;
                            }

                            employeeInfoManageService_g.validate.jobCode(
                                {"jobCode_eq": modelValue, "companyCode_eq": rv1_attr, type: "equale"},
                                function(result) {
                                    //console.log(result);
                                    if (result.status == "SUCCESS") {
                                        ngModelCtrl.$setValidity('remote', true);
                                    } else {
                                        ngModelCtrl.$setValidity('remote', false);
                                    }
                                },
                                function(result) {
                                    //console.log(result);
                                    ngModelCtrl.$setValidity('remote', true);
                                }
                            );
                        } else if (attr["rvtype"] == "ttinfoname") {
                            if (!value) {
                                ngModelCtrl.$setValidity('remote', false);
                                return;
                            }

                            console.log("rv1：" + value);

                            timeTableManageService_g.validate.ttinfoname(
                                {"name_eq": modelValue, "xl.id_eq": value, type: "equale"},
                                function(result) {
                                    //console.log(result);
                                    if (result.status == "SUCCESS") {
                                        ngModelCtrl.$setValidity('remote', true);
                                    } else {
                                        ngModelCtrl.$setValidity('remote', false);
                                    }
                                },
                                function(result) {
                                    //console.log(result);
                                    ngModelCtrl.$setValidity('remote', true);
                                }
                            );
                        }

                    });
                });
            }
        };
    }]);


/**
 * saSelect2指令，根据属性值，动态载入数据，然后支持拼音搜索，点击右边的按钮清除选择并重新载入数据。
 * 1、compile阶段使用的属性如下：
 *      required：用于和表单验证连接，指定成required="true"才有效。
 * 2、link阶段使用的属性如下
 *      model：关联的模型对象
 *      name：表单验证时需要的名字
 *      type：关联的那种数据值（xl/cl/ry）-> 对应线路信息/车辆信息/人员信息，后面有的继续加
 *      modelcolname1：关联的模型字段名字1（一般应该是编码字段）
 *      modelcolname2：关联的模型字段名字2（一般应该是名字字段）
 *      datacolname1；内部数据对应的字段名字1（与模型字段1对应）
 *      datacolname2：内部数据对应的字段名字2（与模型字段2对应）
 *      showcolname：下拉框显示的内部数据字段名（注意：不是模型数据字段名），TODO：以后考虑放动态表达式，并在compile阶段使用
 *      placeholder：select placeholder字符串描述
 *
 * $$pyFilter，内部的filter指令，结合简拼音进行拼音过滤。
 * $$SearchInfoService_g，内部使用的数据服务
 */
// saSelect2指令使用的内部信service
angular.module('ScheduleApp').factory('$$SearchInfoService_g', ['$resource', function($resource) {
    return {
        xl: $resource(
            '/line/:type',
            {order: 'name', direction: 'ASC'},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        zd: $resource(
            '/stationroute/stations',
            {order: 'stationCode', direction: 'ASC'},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        tcc: $resource(
            '/carpark/:type',
            {order: 'parkCode', direction: 'ASC'},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        ry: $resource(
            '/personnel/:type',
            {order: 'personnelName', direction: 'ASC'},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        cl: $resource(
            '/cars/:type',
            {order: "insideCode", direction: 'ASC'},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        ttInfo: $resource(
            '/tic/:type',
            {order: "name", direction: 'ASC'},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        cci: $resource(
            '/cci/cars',
            {},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }

        ),
        cci2: $resource(
            '/cci/:type',
            {},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        cci3: $resource(
            '/cci/cars2',
            {},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }

        ),
        eci: $resource(
            '/eci/jsy',
            {},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        ),
        eci2: $resource(
            '/eci/spy',
            {},
            {
                list: {
                    method: 'GET',
                    isArray: true
                }
            }
        )
    }
}]);
angular.module('ScheduleApp').filter("$$pyFilter", function() {
    return function(items, props) {
        var out = [];
        var limit = props["limit"] || 20; // 默认20条记录

        if (angular.isArray(items)) {
            items.forEach(function(item) {
                if (out.length < limit) {
                    if (props.search) {
                        var upTerm = props.search.toUpperCase();
                        if(item.fullChars.indexOf(upTerm) != -1
                            || item.camelChars.indexOf(upTerm) != -1) {
                            out.push(item);
                        }
                    }
                }
            });
        }

        return out;
    };
});
angular.module('ScheduleApp').directive("saSelect2", [
    '$timeout', '$$SearchInfoService_g',
    function($timeout, $$searchInfoService_g) {
        return {
            restrict: 'E',
            templateUrl: '/pages/scheduleApp/module/other/MySearchSelectTemplate.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/dt/MyUiSelectWrapTemplate1.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");
                            // 清空内部数据
                            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) {

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

    }
]);

/**
 * 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/dt/MyCheckboxGroupWrapTemplate.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/dt/MyDateGroupWrapTemplate.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/dt/MyGuideboardGroupWrapTemplate.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/dt/MyEmployeeGroupWrapTemplate.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) {
                                console.log("开始初始化数据");

                                // 判定是否分班，字符串中包含-就是了
                                if (self.$$data_ry_first_data.indexOf("-") != -1) { // 分班
                                    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 {
                                    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, 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;
                            }
                        });

                    }
                }

            }
        }
    }
]);