prj-common-directive.js 340 KB

Edit Raw Blame History

//自定义指令
/**
 * loading载入中指令。
 */
angular.module('ScheduleApp').directive(
    'loadingWidget',
    [
        'requestNotificationChannel',
        function(requestNotificationChannel) {
            return {
                restrict: 'A',

                compile: function(tElem, tAttrs) {
                    var loadingCount = 0;

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

                        },
                        post: function(scope, element, attr) {
                            // 初始隐藏loading界面
                            element.hide();

                            // 开始请求通知处理
                            requestNotificationChannel.onRequestStarted(scope, function(requestInfo) {
                                if (loadingCount == 0) {
                                    element.show();
                                }
                                loadingCount ++;
                                // TODO：以后在载入中显示requestInfo相关信息
                                console.log(requestInfo);
                                console.log(loadingCount);
                            });
                            // 请求结束通知处理
                            requestNotificationChannel.onRequestEnded(scope, function() {
                                loadingCount --;
                                if (loadingCount == 0) {
                                    element.hide();
                                }

                                console.log(loadingCount);
                            });
                        }
                    };
                }

            };

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

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

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

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

                    },

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

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

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

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

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

                    },

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

/**
 * remoteValidationt3 远程验证指令（监控依赖的model变化）
 * 属性如下：
 * remotevtype（必须）：验证类型（在service中有对应映射），如rvtype="xl"
 * remotemodel（必须）：关联的model
 * remotemodelcol（必须）：关联的model属性
 */
angular.module('ScheduleApp').directive(
    'remoteValidation3',
    [
        '$$SearchInfoService_g',
        '$q',
        function($$SearchInfoService_g, $q) {
            return {
                restrict: 'A', // 属性
                require: '^ngModel', // 依赖所属指令的ngModel
                compile: function(tElem, tAttrs) {
                    var remotevtype_attr = tAttrs['remotevtype'];
                    var remotemodel_attr = tAttrs['remotemodel'];
                    var remotemodelcol_attr = tAttrs['remotemodelcol'];
                    if (!remotevtype_attr) {
                        throw new Error("remotevtype属性必须填写");
                    }
                    if (!remotemodel_attr) {
                        throw new Error("remotemodel属性必须填写");
                    }
                    if (!remotemodelcol_attr) {
                        throw new Error("remotemodelcol属性必须填写");
                    }

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

                        },

                        post: function(scope, element, attr, ngModelCtrl) {
                            ngModelCtrl.$asyncValidators.remote =
                                function(modelValue, viewValue) {
                                    var deferred = $q.defer();

                                    // 远端验证service
                                    var param = JSON.parse(attr['remotemodel']);
                                    console.log(param);
                                    param[remotemodelcol_attr] = modelValue;
                                    $$SearchInfoService_g.validate[remotevtype_attr].remote.do(
                                        param,
                                        function(result) {
                                            if (result.status == "SUCCESS") {
                                                deferred.resolve();
                                            } else {
                                                scope.$remote_msg = result.msg;
                                                deferred.reject();
                                            }
                                        },
                                        function(result) {
                                            deferred.reject();
                                        }
                                    );

                                    return deferred.promise;
                                };
                        }
                    };
                }
            }
        }
    ]
);
/**
 * remoteWarn指令：远程验证警告，作为属性放在某个指令上。
 *                TODO：暂时没法整合到form上，类似$error这样
 * 属性如下：
 * remotewtype（必须）：验证类型（在service中有对应映射），如rvtype="xl"
 * remotewparam（必须）：后端判定查询参数，如rvparam={{ {'xl.id_eq': '123'} | json }}
 * remotewmsgprop（必须）：警告信息属性名
 */
angular.module('ScheduleApp').directive('remoteWarn', [
    '$$SearchInfoService_g',
    function($$SearchInfoService_g) {
        return {
            restrict: "A", // 属性
            required: "^ngModel", // 依赖所属指令的ngModel
            compile: function(tElem, tAttrs) {
                // 验证属性
                if (!tAttrs["remotewtype"]) { // 验证类型
                    throw {msg : "remotewtype属性必须填写"};
                }
                if (!$$SearchInfoService_g.validate[tAttrs["remotewtype"]]) {
                    throw {msg : tAttrs["remotevtype"] + "验证类型不存在"};
                }
                if (!tAttrs["remotewparam"]) { // 查询参数
                    throw {msg : "remotevparam属性必须填写"};
                }
                if (!tAttrs["remotewmsgprop"]) { // 警告信息属性名
                    throw {msg : "remotewmsgprop属性必须填写"}
                }

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

                // 验证数据
                var $$internal_validate = function(ngModelCtrl, scope) {
                    if ($watch_rvtype && $watch_rvparam_obj && $remotewmsgprop) {
                        // 获取查询参数模版
                        var paramTemplate = $$SearchInfoService_g.validate[$watch_rvtype].template;
                        if (!paramTemplate) {
                            throw {msg : $watch_rvtype + "查询模版不存在"};
                        }

                        // 判定如果参数对象不全，没有完全和模版参数里对应上，则不验证
                        var isParamAll = true;
                        for (var key in paramTemplate) {
                            if (key != "id" && !$watch_rvparam_obj[key]) { // id去掉
                                isParamAll = false;
                                break;
                            }
                        }

                        if (!isParamAll) {
                            scope["ctrl"][$remotewmsgprop] = undefined;
                        } else { // 开始验证警告
                            $$SearchInfoService_g.validate[$watch_rvtype].remote.do(
                                $watch_rvparam_obj,
                                function(result) {
                                    if (result.status == "SUCCESS") {
                                        scope["ctrl"][$remotewmsgprop] = undefined;
                                    } else {
                                        scope["ctrl"][$remotewmsgprop] = result.msg;
                                    }
                                },
                                function(result) {
                                    scope["ctrl"][$remotewmsgprop] = undefined;
                                }
                            );
                        }
                    }

                };

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

                    },

                    post: function(scope, element, attr, ngModelCtrl) {
                        /**
                         * 监控验证类型属性变化。
                         */
                        attr.$observe("remotewtype", function(value) {
                            if (value && value != "") {
                                $watch_rvtype = value;
                                $$internal_validate(ngModelCtrl, scope);
                            }
                        });

                        /**
                         * 监控查询结果属性变化。
                         */
                        attr.$observe("remotewparam", function(value) {
                            if (value && value != "") {
                                $watch_rvparam_obj = JSON.parse(value);
                                $$internal_validate(ngModelCtrl, scope);
                            }
                        });

                        /**
                         * 监控警告信息属性名变化。
                         */
                        attr.$observe("remotewmsgprop", function(value) {
                            if (value && value != "") {
                                $remotewmsgprop = value;
                                $$internal_validate(ngModelCtrl, scope);
                            }
                        });

                    }
                };
            }
        };
    }
]);

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

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

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

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

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

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

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

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

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


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

                // 2、处理属性

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

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

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

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

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

                                    }
                                );
                            }
                        };

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                                            }
                                        );
                                    }
                                }
                            }

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

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

                            }

                        };


                        // TODO：

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

                                    //

                                    obj["type"] = "all";

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

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

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

    }
]);


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                                    }

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

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

                                }
                            );
                        };

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

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

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

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

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

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

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

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

                            }

                        });

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

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

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

            }

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

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

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

            },

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

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

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

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

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

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


                // 当前的数据模式，ajax,dic,local
                var dataModelType = undefined;

                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.indexOf('_') > 0) {
                                scope[ctrlAs].model[$dcname_attr] = $item[$icname_attr];
                            } else {
                                eval("scope[ctrlAs].model" + "." + $dcname_attr + " = $item" + "." + $icname_attr + ";");
                            }


                            eval("var obj=" + $cmaps_attr);
                            for (var mc in obj) { // model的字段名:内部数据源对应字段名
                                var ic = obj[mc]; // 内部数据源对应字段
                                if (mc.indexOf('_') > 0) {
                                    scope[ctrlAs].model[mc] = $item[ic];
                                } else {
                                    try {
                                        eval("scope[ctrlAs].model" + "." + mc + " = $item" + "." + ic + ";");
                                    } catch (e) {
                                        // TODO：
                                        eval("scope[ctrlAs].model" + "." + mc + " = null;");
                                    }

                                }
                            }
                        };

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

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

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

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

                        /**
                         * 验证内部数据，更新外部model
                         */
                        scope[ctrlAs].$$internal_validate_model = function() {
                            // TODO：
                            //console.log(scope[ctrlAs].$$internal_select_value);
                            //console.log(scope[ctrlAs].$$data_real);

                            if (scope[ctrlAs].$$internal_select_value) {
                                var select_value_temp = scope[ctrlAs].$$internal_select_value;
                                if (scope[ctrlAs].$$data_real && scope[ctrlAs].$$data_real.length > 0) {
                                    var obj;
                                    for (var j = 0; j < scope[ctrlAs].$$data_real.length; j++) {
                                        if (eval("scope[ctrlAs].$$data_real[j]" + "." + $icname_attr + " == select_value_temp")) {
                                            obj = angular.copy(scope[ctrlAs].$$data_real[j]);
                                            break;
                                        }
                                    }
                                    if (obj) { // 在data中判定有没有
                                        // 初始化的时候，模拟选中uiselect
                                        scope[ctrlAs].$$internal_select_fn(obj);

                                        for (var k = 0; k < scope[ctrlAs].$$data.length; k++) {
                                            if (eval("scope[ctrlAs].$$data[k]" + "." + $icname_attr + " == obj." + $icname_attr)) {
                                                obj = undefined;
                                                break;
                                            }
                                        }
                                        if (obj) {
                                            scope[ctrlAs].$$data.push(obj);
                                        }
                                        // 更新内部model，用于外部验证
                                        // 内部model的值暂时随意，以后再改
                                        scope[ctrlAs].$$internalmodel = {desc: "ok"};

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

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

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

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

                            };

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

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

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

                                return;
                            }

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

                            // 添加线路查询用的公司分公司信息
                            if (atype == 'xl') {
                                if (UserPrincipal.getGsStrs().length > 0) {
                                    ajaxparamobj["cgsbm_in"] = UserPrincipal.getGsStrs().join(",");
                                }
                            }

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

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

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

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

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

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

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

                            //console.log(origin_dicgroup);

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

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

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

                        /**
                         * 内部方法，读取本地动态数据源。
                         * @param type
                         */
                        scope[ctrlAs].$$internal_local_data = function(type) {
                            // 重新创建内部保存的数据
                            scope[ctrlAs].$$data_real = [];
                            // 本地动态数据直接显示，暂时不优化
                            var ldata = DataStore.getData(type);
                            for (var i = 0; i < ldata.length; i++) {
                                // 闭包绑定返回最终查询的值
                                var calcu_str = scope[ctrlAs].$$internal_match_str(ldata[i]);
                                if (calcu_str) {
                                    // 全拼
                                    if (!ldata[i]["$fullChars"]) {
                                        ldata[i]["$fullChars"] = pinyin.getFullChars(calcu_str);
                                    }
                                    // 简拼
                                    if (!ldata[i]["$camelChars"]) {
                                        ldata[i]["$camelChars"] = pinyin.getCamelChars(calcu_str);
                                    }
                                    // 原值
                                    if (!ldata[i]["$calcu_str"]) {
                                        ldata[i]["$calcu_str"] = calcu_str;
                                    }

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

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

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

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

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

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

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

                                // dsparams格式如下：
                                // {type: 'ajax', param: 'ajax查询参数对象', atype: 'ajax查询累西'}
                                // {type: 'dic', param: 'dic名字'}
                                // {type: 'local', param: '本地存储type名字'}
                                // {type: 'passdata', : 'ldata': '本地存储数据'}

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

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

                            }
                        });

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

                                } else {
                                    console.log("saSelect5 监控到外部模型" + $dcname_attr + "属性值变化，old=" + oldValue + "，new=" + newValue);
                                    scope[ctrlAs].$$internal_select_value = newValue;
                                    scope[ctrlAs].$$internal_validate_model();
                                }
                            },
                            true
                        );
                    }
                };
            }
        };
    }
]);
/**
 * mySelect指令，封装uiselect指令，封装内部数据获取，只支持单选
 * cm（必须）：绑定外部对象，因为关联的字段不只一个，单独使用ngModel不够
 * cmoptions（必须）：描述绑定的逻辑配置对象，格式如下：
 *
 * // TODO：
 */
angular.module('ScheduleApp').directive('mySelect', [
    function() {
        return {
            restrict: 'E',
            template: '<div>bioxuxuan</div>',
            require: 'ngModel',
            compile: function(tElem, tAttrs) {
                return {
                    pre: function(scope, element, attr) {

                    },
                    post: function(scope, element, attr, ngModelCtr) {
                        // model -> view
                        ngModelCtr.$formatters.push(function(modelValue) {
                            // 监控model的变化
                            if (typeof modelValue != "undefined") {
                                console.log(modelValue);

                                return modelValue;
                            }
                        });

                        ngModelCtr.$render = function() {
                            if (typeof scope.ctrl.say != "undefined") {
                                element.find('div').css('color', 'red');
                            }
                        };

                        ngModelCtr.$setViewValue("init value");


                    }
                }
            }
        }
    }
]);

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

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

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

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

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

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

                },

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

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

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


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

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

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

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

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

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

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

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

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


                            },
                            true
                        );

                        // TODO：

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

                            }
                        });
                    }

                };


            }

        };
    }
]);


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

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

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

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

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

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


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

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

                                }

                            }
                        );

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

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

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

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

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


                            }
                        });

                    }

                };
            }
        }
    }
]);


/**
 * saFbgsgroup指令
 * 属性如下：
 * name（必须）：控件的名字
 * model（必须）：指定一个外部object，独立作用域，如：model=ctrl.employeeInfoForSave
 * fbgsvalue（必须）：绑定的model翻班格式值，如：fbgsvalue={{ctrl.employeeInfoForSave.fbgs}}
 * fbgsname（必须）：绑定的model翻班格式字段名，如：fbgsname=fbgs
 *
 * required（可选）：是否要用required验证
 *
 */
angular.module('ScheduleApp').directive(
    'saFbgsgroup',
    [
        function() {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/fbgsGroup/saFbgsgroupTemplate.html',
                scope: {
                    model: "=" // 独立作用域，关联外部的模型object
                },
                controllerAs: '$saFbgsgroupCtrl',
                bindToController: true,
                controller: function() {
                    var self = this;

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

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

                /**
                 * 此阶段可以改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 $fbgsname_attr = tAttrs["fbgsname"]; // 绑定的model翻班格式字段名

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

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

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

                        },

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

                            /**
                             * 路牌列表点击（路牌列表中选中路牌）
                             * @param fbcode
                             */
                            scope[ctrlAs].$$internal_fb_click = function(fbcode) {
                                scope[ctrlAs].$$dataSelected.push(fbcode);
                            };

                            /**
                             * 选中的路牌双击（删除选中的路牌）
                             * @param $index
                             */
                            scope[ctrlAs].$$internal_sellplist_dbclick = function($index) {
                                scope[ctrlAs].$$dataSelected.splice($index, 1);
                            };

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

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

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

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

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

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

                            // 监控路牌名称范围值的变化，处理初始化赋值
                            attr.$observe("fbgsvalue", function(value) {
                                var data_temp = scope[ctrlAs].$$dataSelected;

                                if (value && value != "" && data_temp && data_temp.length == 0) { // 初始创建
                                    var data_temp = scope[ctrlAs].$$dataSelected;
                                    var fbgses = [];
                                    var i = 0;

                                    // 分隔翻班格式
                                    if (value.indexOf(",") >= 0) { // 以逗号分隔，如 1,1,0,1
                                        fbgses = value.split(",");
                                    } else {
                                        for (i = 0; i < value.length; i++) { // 字符串形式，如 1101
                                            fbgses.push(value.substr(i, 1));
                                        }
                                    }

                                    for (i = 0; i < fbgses.length; i++) {
                                        if (fbgses[i] == "1" || fbgses[i] == "0") {
                                            data_temp.push(fbgses[i]);
                                        }
                                    }
                                }
                            });
                        }
                    };
                }
            }
        }
    ]);


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

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

                self.$$searchText = undefined; // 搜索值
                self.$$dataSelected = []; // 选中的路牌列表
                self.$$dataSelectedStart = undefined; // 起始路牌
                self.$$isAll = false; // 是否显示全部
                self.$$showNumber = 10; // 显示的记录数
                self.$$calcuData = function() { // 处理$$data数据
                    console.log(self.$$searchText);
                    angular.forEach(self.$$dataReal, function(obj) {
                        if (self.$$isAll) { // 显示全部
                            if (self.$$searchText && self.$$searchText != "") { // 有筛选条件
                                if (obj.$fullChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                    || obj.$camelChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                    || obj.lpname.indexOf(self.$$searchText.toUpperCase()) != -1) {
                                    this.push(obj);
                                }
                            } else {
                                this.push(obj);
                            }
                        } else { // 显示限定数量
                            if (this.length < self.$$showNumber) {
                                if (self.$$searchText && self.$$searchText != "") { // 有筛选条件
                                    if (obj.$fullChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                        || obj.$camelChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                        || obj.lpname.indexOf(self.$$searchText.toUpperCase()) != -1) {
                                        this.push(obj);
                                    }
                                } else {
                                    this.push(obj);
                                }
                            }
                        }
                    }, self.$$data);

                };

                //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;
                        }

                        // 监听搜索框，keydwon，keyup事件
                        tElem.on('keydown', '[name=lpsearch]', function(event) {
                            if (event.keyCode == 13) { // 阻止回车事件造成的form提交
                                return false;
                            }
                        });
                        tElem.on('keyup', '[name=lpsearch]', function() {
                            // 因为在dom事件里修改了model的值，必须写在scope.$apply中，否则页面上绑定效果无
                            // 另一种做法可以写在$watch方法中
                            scope.$apply(function() {
                                scope[ctrlAs].$$data = [];
                                scope[ctrlAs].$$calcuData();

                            });
                        });


                        /**
                         * 路牌列表点击（路牌列表中选中路牌）
                         * @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();
                            }
                        );

                        // 监控是否显示所有数据，$$isAll 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$isAll;
                            },
                            function(newValue, oldValue) {
                                console.log("dfdfdfdfdf");
                                if (scope[ctrlAs].$$dataReal.length > 0) {
                                    scope[ctrlAs].$$data = [];
                                    scope[ctrlAs].$$calcuData();
                                }
                            },
                            true
                        );

                        // 监控线路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].$$dataReal = [];
                                        angular.forEach(result.content, function(obj) {
                                                this.push({
                                                    lpid: obj.id,
                                                    lpname: obj.lpName,
                                                    isstart: false,
                                                    '$fullChars': pinyin.getFullChars(obj.lpName), // 全拼
                                                    '$camelChars': pinyin.getCamelChars(obj.lpName) // 简拼
                                                });
                                            }, scope[ctrlAs].$$dataReal);

                                        scope[ctrlAs].$$data = [];
                                        scope[ctrlAs].$$calcuData();

                                        if (scope[ctrlAs].$$data_init) {
                                            scope[ctrlAs].$$dataSelected = [];
                                            scope[ctrlAs].$$dataSelectedStart = undefined;
                                            scope[ctrlAs].$$internalmodel = undefined;

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

                                    }
                                );

                            }
                        });

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

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

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


                    }
                }

            }
        }
    }
]);


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

                // 测试数据
                //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.$$searchText = undefined; // 搜索值
                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.$$isAll = false; // 是否显示全部
                self.$$showNumber = 10; // 显示的记录数
                self.$$calcuData = function() { // 处理$$data数据
                    console.log(self.$$searchText);
                    angular.forEach(self.$$dataReal, function(obj) {
                        if (self.$$isAll) { // 显示全部
                            if (self.$$searchText && self.$$searchText != "") { // 有筛选条件
                                if (obj.$fullChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                    || obj.$camelChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                    || obj.$str.indexOf(self.$$searchText.toUpperCase()) != -1) {
                                    this.push(obj);
                                }
                            } else {
                                this.push(obj);
                            }
                        } else { // 显示限定数量
                            if (this.length < self.$$showNumber) {
                                if (self.$$searchText && self.$$searchText != "") { // 有筛选条件
                                    if (obj.$fullChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                        || obj.$camelChars.indexOf(self.$$searchText.toUpperCase()) != -1
                                        || obj.$str.indexOf(self.$$searchText.toUpperCase()) != -1) {
                                        this.push(obj);
                                    }
                                } else {
                                    this.push(obj);
                                }
                            }
                        }
                    }, self.$$data);

                };


                //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;
                        }

                        // 监听搜索框，keydwon，keyup事件
                        tElem.on('keydown', '[name=rysearch]', function(event) {
                            if (event.keyCode == 13) { // 阻止回车事件造成的form提交
                                return false;
                            }
                        });
                        tElem.on('keyup', '[name=rysearch]', function() {
                            // 因为在dom事件里修改了model的值，必须写在scope.$apply中，否则页面上绑定效果无
                            // 另一种做法可以写在$watch方法中
                            scope.$apply(function() {
                                scope[ctrlAs].$$data = [];
                                scope[ctrlAs].$$calcuData();

                            });
                        });


                        /**
                         * 人员配置列表点击（人员配置列表中选中路牌）
                         * @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,
                                        jcode: data_temp[$index].jcode,
                                        scode: data_temp[$index].scode,
                                        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,
                                            jcode: data_temp[$index].jcode,
                                            scode: data_temp[$index].scode,
                                            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,
                                                    jcode: data_temp[$index].jcode,
                                                    scode: data_temp[$index].scode,
                                                    isselected: false
                                                }, {
                                                    id : data_temp[$index].id,
                                                    dbbm: data_temp[$index].dbbm,
                                                    jsy: data_temp[$index].jsy,
                                                    spy: data_temp[$index].spy,
                                                    jcode: data_temp[$index].jcode,
                                                    scode: data_temp[$index].scode,
                                                    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.$$dataReal;
                            var dataSelect_temp = self.$$dataSelected;
                            var dataFBSelect_temp = self.$$dataFBSelected;
                            var dbbmnames = null;
                            var dbbmnamegroup = null;
                            var rycids = null;
                            var rycidgroup = null;

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

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

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

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

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

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

                                    }

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


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

                                    // 搭班编码、人员配置id
                                    dbbmnames = self.$$data_ry_first_data.split(",");
                                    rycids = self.$$data_rycid_first_data.split(",");
                                    for (i = 0; i < dbbmnames.length; i++) {
                                        dataSelect_temp.push({
                                            id: rycids[i],
                                            dbbm: dbbmnames[i],
                                            isstart: false
                                        });
                                        for (j = 0; j < data_temp.length; j++) {
                                            if (dataSelect_temp[i].dbbm == data_temp[j].dbbm) {
                                                dataSelect_temp[i].jsy = data_temp[j].jsy;
                                                dataSelect_temp[i].spy = data_temp[j].spy;
                                                dataSelect_temp[i].jcode = data_temp[j].jcode;
                                                dataSelect_temp[i].scode = data_temp[j].scode;
                                                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();
                            }
                        );

                        // 监控是否显示所有数据，$$isAll 变化
                        scope.$watch(
                            function() {
                                return scope[ctrlAs].$$isAll;
                            },
                            function(newValue, oldValue) {
                                console.log("dfdfdfdfdf");
                                if (scope[ctrlAs].$$dataReal.length > 0) {
                                    scope[ctrlAs].$$data = [];
                                    scope[ctrlAs].$$calcuData();
                                }
                            },
                            true
                        );


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

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

                                        scope[ctrlAs].$$dataReal = [];
                                        angular.forEach(result.content, function(obj) {
                                            var n1 = obj.jsy == null ? "" : (obj.jsy.personnelName || "");
                                            var n2 = obj.spy == null ? "" : (obj.spy.personnelName || "");
                                            //var n3 = obj.dbbm || "";
                                            var c1 = obj.jsy == null ? "" : (obj.jsy.jobCode || "");
                                            var c2 = obj.spy == null ? "" : (obj.spy.jobCode || "");

                                            if (c1.indexOf("-") > 0) {
                                                c1 = c1.substr(3);
                                            }
                                            if (c2.indexOf("-") > 0) {
                                                c2 = c2.substr(3);
                                            }

                                            var str = [];
                                            str.push(n1);
                                            str.push(n2);
                                            //str.push(n3);
                                            str.push(c1);
                                            str.push(c2);
                                            this.push({
                                                id: obj.id,
                                                dbbm: obj.dbbm,
                                                jsy: n1,
                                                spy: n2,
                                                jcode: c1,
                                                scode: c2,
                                                '$fullChars': pinyin.getFullChars(str.join("-")), // 全拼
                                                '$camelChars': pinyin.getCamelChars(str.join("-")), // 简拼
                                                '$str': str.join("-")
                                            });
                                        }, scope[ctrlAs].$$dataReal);

                                        scope[ctrlAs].$$data = [];
                                        scope[ctrlAs].$$calcuData();

                                        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].$$searchText = undefined;
                                        }
                                        scope[ctrlAs].$$data_xl_first_init = true;
                                    },
                                    function(result) {

                                    }
                                );

                            }
                        });

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

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

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

                    }
                }

            }
        }
    }
]);


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

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


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

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

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

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

            },

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

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

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

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

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

                        // TODO：


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

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


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

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

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

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

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

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

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

                        };

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

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

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

                            var i = 0;
                            var j = 0;

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

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

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

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

                        };

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

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

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

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

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

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

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

                    }
                }

            }
        }
    }
]);
/**
 * saTimeTable指令，时刻表显示指令，excel表格形式，支持菜单，事件处理。
 * name（必须），控件的名字
 * celldbclickFn，单元格双击事件
 * lpbxdbclickFn，路牌班型单元双击事件
 * ds，外部数据源
 *
 * TODO：优化开发中
 *
 */

angular.module('ScheduleApp').factory(
    'SaTimeTableUtils',
    [
        function() {
            // 内部班次信息类
            // detailInfo是后台返回的数据，格式如下：
            // {"ttdid":null,"fcsj":"3/17.10","bc_type":null,"xldir":null,"isfb":false,"qdz":null,"zdz":null,"tcc":null}
            var BcInfo = function(detailInfo) {
                this.ttdid = detailInfo && detailInfo.ttdid; // 时刻表id
                this.fcsj = detailInfo && detailInfo.fcsj; // 发车时间
                this.bc_type = detailInfo && detailInfo.bc_type; // 班次类型
                this.xldir = detailInfo && detailInfo.xldir; // 线路上下行
                this.ists = detailInfo && detailInfo.ists; // 是否停驶
                this.isfb = detailInfo && detailInfo.isfb; // 是否分班
                this.qdzCode = detailInfo && detailInfo.qdzCode; // 起点站Code
                this.zdzCode = detailInfo && detailInfo.zdzCode; // 终点站Code
                this.bcsj = detailInfo && detailInfo.bcsj; // 班次历时

                // 路牌信息
                this.lpId = undefined; // id
                this.lpName = undefined; // 名字

                // 发车序号，班次数
                this.fcno = undefined;
                this.bcs = undefined;

                this.sel = false; // 是否被选中

                // 其余函数判定的内部保存值
                this.isCanSel = false; // 是否能被选择
                this.isInValid = false; // 数据是否无效

            };
            BcInfo.prototype.canUpdate = function() { // 是否能更新
                if (this.sel && this.ttdid) {
                    return true;
                } else {
                    return false;
                }
            };
            BcInfo.prototype.canDelete = function() { // 是否能删除
                if (this.sel && this.ttdid) {
                    return true;
                } else {
                    return false;
                }
            };
            BcInfo.prototype.canSel = function() { // 是否能选中
                if (this.ttdid) {
                    this.isCanSel = true;
                    return true;
                } else if (this.fcsj) {
                    // 没有ttdid，有fcsj标识，
                    // 由于是后台返回数据的格式，这种就是路牌和汇总信息，不能选中
                    this.isCanSel = false;
                    return false;
                } else {
                    // 都是空的，表示是一个空班次，可以选中
                    this.isCanSel = true;
                    return true;
                }
            };
            BcInfo.prototype.validInfo = function() { // 验证班次信息内容是否正确
                if (this.canSel() && this.ttdid) {
                    if (!this.qdzCode || // 起点站编码为空判定
                        !this.zdzCode || // 终点站编码为空判定
                        (!this.bcsj && this.bcsj !== 0)) { // 班次历时为空判定
                        this.isInValid = true;
                    } else {
                        this.isInValid = false;
                    }
                } else {
                    this.isInValid = false;
                }
            };

            BcInfo.prototype.where = function(xldir, startTime_h_m, endTime_h_m, isInOut) { // 判定班次是否在指定条件内
                var fcsj_m_h = [];
                fcsj_m_h[0] = parseInt(this.fcsj.split(":")[0]);
                fcsj_m_h[1] = parseInt(this.fcsj.split(":")[1]);

                var fcsj = new Date(2000,1,1);
                fcsj.setHours(fcsj_m_h[0]);
                fcsj.setMinutes(fcsj_m_h[1]);

                var s_temp_date = new Date(2000, 1, 1);
                var e_temp_date = new Date(2000, 1, 1);

                if (xldir == 2) { // 上下行
                    // 判定是否要进出场班次
                    if (isInOut == false && (this.bc_type == "in" || this.bc_type == "out")) {
                        return false;
                    }

                    if (startTime_h_m) {
                        if (endTime_h_m) {
                            s_temp_date.setHours(startTime_h_m[0]);
                            s_temp_date.setMinutes(startTime_h_m[1]);
                            e_temp_date.setHours(endTime_h_m[0]);
                            e_temp_date.setMinutes(endTime_h_m[1]);
                            return fcsj >= s_temp_date && fcsj <= e_temp_date;
                        } else {
                            s_temp_date.setHours(startTime_h_m[0]);
                            s_temp_date.setMinutes(startTime_h_m[1]);
                            return fcsj >= s_temp_date;
                        }
                    } else {
                        if (endTime_h_m) {
                            e_temp_date.setHours(endTime_h_m[0]);
                            e_temp_date.setMinutes(endTime_h_m[1]);
                            return fcsj <= e_temp_date;
                        } else {
                            return false;
                        }
                    }
                } else {
                    // 判定是否要进出场班次
                    if (isInOut == false && (this.bc_type == "in" || this.bc_type == "out")) {
                        return false;
                    }

                    if (xldir == this.xldir) {
                        if (startTime_h_m) {
                            if (endTime_h_m) {
                                s_temp_date.setHours(startTime_h_m[0]);
                                s_temp_date.setMinutes(startTime_h_m[1]);
                                e_temp_date.setHours(endTime_h_m[0]);
                                e_temp_date.setMinutes(endTime_h_m[1]);
                                return fcsj >= s_temp_date && fcsj <= e_temp_date;
                            } else {
                                s_temp_date.setHours(startTime_h_m[0]);
                                s_temp_date.setMinutes(startTime_h_m[1]);
                                return fcsj >= s_temp_date;
                            }
                        } else {
                            if (endTime_h_m) {
                                e_temp_date.setHours(endTime_h_m[0]);
                                e_temp_date.setMinutes(endTime_h_m[1]);
                                return fcsj <= e_temp_date;
                            } else {
                                return true;
                            }
                        }
                    } else {
                        return false;
                    }
                }
            };

            return {
                createBcInfo: function(detailInfo, lpDetailInfo) {
                    var bcInfo = new BcInfo(detailInfo);
                    if (!bcInfo.ttdid && bcInfo.fcsj && bcInfo.fcsj.indexOf('_') > 0) {
                        var temp_info = bcInfo.fcsj.split('_');
                        // 添加信息的属性
                        bcInfo.lpName = temp_info[1];
                        bcInfo.lpId = temp_info[0];
                        // 修改fcsj为路牌名字
                        bcInfo.fcsj = bcInfo.lpName;
                    }

                    // 重新设定路牌信息
                    if (!bcInfo.lpId) {
                        bcInfo.lpId = lpDetailInfo.lpId;
                        bcInfo.lpName = lpDetailInfo.lpName;
                    }

                    return bcInfo;
                },

                /**
                 * 创建班型信息。
                 * @param bcInfo new BcInfo
                 */
                createBxInfo: function(bcInfo) {
                    var bxInfo = {};
                    bxInfo.xl = {};
                    bxInfo.ttinfo = {};
                    bxInfo.lp = {};
                    bxInfo.lp.id = bcInfo && bcInfo.lpId;
                    bxInfo.lp.lpName = bcInfo && bcInfo.lpName;
                    bxInfo.bxType1 = "_null_";
                    bxInfo.bxType2 = "_null_";
                    bxInfo.gs = "0";
                    bxInfo.bxPds = "0";

                    return bxInfo;
                },

                // TODO：
                initTTInfoDetail: function(formobj, cellinfo, colinfo, xlid, xlname, ttid, ttname) {
                    formobj.xl = {};
                    formobj.xl.id = xlid;
                    formobj.xl.name = xlname;
                    formobj.ttinfo = {};
                    formobj.ttinfo.id = ttid;
                    formobj.ttinfo.name = ttname;
                    formobj.lp = {};
                    formobj.lp.id = cellinfo.lpId;
                    formobj.lp.lpName = cellinfo.lpName;
                    formobj.fcno = cellinfo.fcno;
                    formobj.bcs = cellinfo.bcs;
                    formobj.isFB = cellinfo.isfb;
                    formobj.isTS = 0;

                    formobj.bcType = colinfo.bc_type;
                    formobj.xlDir = colinfo.xldir;

                    formobj.qdzCode = colinfo.qdzCode;
                    formobj.zdzCode = colinfo.zdzCode;

                }
            };
        }
    ]
);

angular.module('ScheduleApp').directive(
    'saTimetable',
    [
        '$compile',
        '$window',
        '$timeout',
        function($compile, $window, $timeout) {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/ttinfotable/saTimeTableTemplate.html',
                scope: { // 独立作用域
                    // 注意：数据暂时从外部ngModel里获取，以后内部自己处理
                    ds: "=ngModel",
                    celldbclickFn: "&celldbclick",
                    lpbxdbclickFn: "&lpbxdbclick"

                    // TODO：

                },
                controllerAs: "$saTimeTableCtrl",
                bindToController: true,
                controller: function() {
                    var self = this;
                    this.$$headToolTip = ""; // 表头tooltip信息

                    // TODO：
                },

                /**，
                 * compile阶段，angular还没有编译模版，根据需要可以修改模版dom
                 * @param tElem
                 * @param tAttrs
                 * @returns {{pre: Function, post: Function}}
                 */
                compile: function(tElem, tAttrs) {
                    // 获取属性
                    var $attr_name = tAttrs["name"]; // 控件的名字
                    if (!$attr_name) {
                        throw new Error("saTimeTable指令 name属性required");
                    }
                    var $attr_celldbclick = tAttrs["celldbclick"]; // 单元格双击事件名

                    // 内部controlAs名字
                    var ctrlAs = '$saTimeTableCtrl';

                    // 当前选中的cell
                    var startRowIndex = undefined;
                    var startColIndex = undefined;
                    var shiftKey = false; // shift键是否被按住
                    var ctrlKey = false; // ctrl是否被按住
                    // shift选中的cell
                    var shiftCells = [];

                    // TODO：

                    // 监听滚动条事件
                    //console.log(tElem.find('.tt_table').html());
                    //tElem.on('scroll', '.tt_table', function() {
                    //    // 因为在dom事件里修改了model的值，必须写在scope.$apply中，否则页面上绑定效果无
                    //    // 另一种做法可以写在$watch方法中
                    //    console.log("ssssssssssss......");
                    //});

                    return {
                        pre: function(scope, element, attr) {
                            // TODO：
                            //alert(element.find("#tooltipTest").html());
                            //$compile(element.find("#tooltipTest"))(scope);

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

                            // ------------------- dom事件处理function -----------------//
                            scope[ctrlAs].$$cell_click = function(rowindex, colindex, cell) {
                                console.log("click " + "row=" + rowindex + ",col=" + colindex);
                                var internal_ds = scope[ctrlAs].ds.detailInfos;

                                if (cell.canSel()) { // 是班次的单元格才能操作
                                    cell.sel = !cell.sel;
                                }

                            };
                            scope[ctrlAs].$$cell_dbclick = function(rowindex, colindex, cell) {
                                if (cell.canSel()) { // 是班次的单元格才能操作
                                    if ($attr_celldbclick) {
                                        // 注意调用方法
                                        scope[ctrlAs].celldbclickFn()(rowindex, colindex);
                                    }
                                }
                            };
                            scope[ctrlAs].$$bx_cell_dbclick = function(rowindex) {
                                scope[ctrlAs].lpbxdbclickFn()(rowindex);
                            };

                            // ------------------- 监控function ------------------//
                            // 监控明细数据，生成表头的tooltip
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].ds;
                                },
                                function(newValue, oldValue) {
                                    if (newValue &&
                                        newValue.detailHeads &&
                                        newValue.detailHeads.length > 0) {
                                        var tooltip = [];
                                        tooltip.push("出场");
                                        angular.forEach(newValue.detailHeads, function(value) {
                                            if (value != "出场" &&
                                                value != "路牌" &&
                                                value != "进场" &&
                                                value != "空驶班次/空驶里程" &&
                                                value != "运营班次/运营里程" ) {
                                                var exist = false;
                                                angular.forEach(tooltip, function(tip) {
                                                    if (tip == value) {
                                                        exist = true;
                                                    }
                                                });
                                                if (!exist) {
                                                    tooltip.push(value);
                                                }
                                            }
                                        });
                                        tooltip.push("进场");
                                        scope[ctrlAs].$$headToolTip = tooltip.join(",");
                                    }
                                },
                                true
                            );

                            // 5、全部载入后，输入的
                            $timeout(function() {
                                console.log("宽度宽度：" + element.find(".tt_table_head").width());
                            }, 0);
                        }
                    };
                }

            };
        }
    ]
);

/**
 * saTimetablePreview指令，时刻表预览模式视图。
 */
angular.module("ScheduleApp").directive(
    "saTimetable2",
    [
        '$timeout',
        function($timeout) {
            return {
                restrict : 'E',
                templateUrl : '/pages/scheduleApp/module/common/dts2/ttinfotable/saTimeTablePreViewTemplate.html',
                scope : { // 独立作用域
                    // 使用外部数据源，内部重新组合显示
                    ds : "=ngModel"
                },
                controllerAs : "$saTimeTablePreviewCtrl",
                bindToController: true,
                controller : function() {
                    var self = this;

                    // 内部班次时刻模型
                    self.internalBcModel = {
                        up_qdz_name : "", // 上行起点站名字
                        down_qdz_name : "", // 下行起点站名字
                        up_bc_list_asc : [], // 上行班次列表（按照发车时间升序）
                        down_bc_list_asc : [] // 下行班次列表（按照发车时间升序）
                    };

                    // 内部各个路牌block车次链模型
                    self.internalLpBlockModel = {
                        // key：路牌名字
                        // value: 数组（按照发车时间排序）
                        // value 数据内对象 {fcsj:发车时间,isUp:是否上行,fcno:发车顺序号,index:对应的班次列表索引}
                    };

                    // TODO：
                },

                /**，
                 * compile阶段，angular还没有编译模版，根据需要可以修改模版dom
                 * @param tElem
                 * @param tAttrs
                 * @returns {{pre: Function, post: Function}}
                 */
                compile : function(tElem, tAttrs) {
                    // 获取属性
                    var $attr_name = tAttrs["name"]; // 控件的名字
                    if (!$attr_name) {
                        throw new Error("saTimeTablePreview指令 name属性required");
                    }

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

                    // TODO：

                    //------------------ 内部方法 --------------------//
                    var date_wrap_prefix = "2000-01-01 "; // 包装日期的前缀
                    var date_wrap_format = "YYYY-MM-DD HH:mm"; // 日期格式
                    /**
                     * 将时间包装成日期，方便计算。
                     * @param timeStr 时间格式，如 06:30
                     * @returns moment对象
                     */
                    var _fun_WrapTime = function(timeStr) {
                        return moment(
                            date_wrap_prefix + timeStr,
                            date_wrap_format
                        );
                    };

                    /**
                     * 点击班次html元素（dl），触发班次移动，如下：
                     * 1、点击上行班次，下一个下行班次在下行班次列表中移到中间位置
                     * 2、点击下行班次，下一个上行班次在上行班次列表中移到中间位置
                     * @param ctrl 内部控制器
                     * @param index 班次索引
                     * @param isUp 是否上行
                     * @private
                     */
                    var _fun_bcDDViewMove = function(ctrl, index, isUp) {
                        // 获取当前点击班次对象
                        var oBc;
                        if (isUp) {
                            oBc = ctrl.internalBcModel.up_bc_list_asc[index];
                        } else {
                            oBc = ctrl.internalBcModel.down_bc_list_asc[index];
                        }

                        // 找出车次链中的下一个班次索引，没有就undefined
                        var nextIndex = undefined;
                        var nextBlockBc = undefined;
                        var currentBlockBcIndex = undefined;
                        angular.forEach(ctrl.internalLpBlockModel[oBc.lpName], function(data, i) {
                            if (data.fcsj == oBc.fcsj) {
                                currentBlockBcIndex = i;
                            }
                        });
                        if (currentBlockBcIndex != undefined &&
                            currentBlockBcIndex < (ctrl.internalLpBlockModel[oBc.lpName].length - 1)) {
                            nextBlockBc = ctrl.internalLpBlockModel[oBc.lpName][currentBlockBcIndex + 1];
                            nextIndex = nextBlockBc.index;
                        }
                        // 先删除click标记，再添加
                        angular.forEach(ctrl.internalBcModel.up_bc_list_asc, function(data) {
                            delete data["isClick"];
                        });
                        angular.forEach(ctrl.internalBcModel.down_bc_list_asc, function(data) {
                            delete data["isClick"];
                        });
                        oBc.isClick = true;
                        if (nextIndex) {
                            if (nextBlockBc.isUp) {
                                ctrl.internalBcModel.up_bc_list_asc[nextIndex].isClick = true;
                            } else {
                                ctrl.internalBcModel.down_bc_list_asc[nextIndex].isClick = true;
                            }
                        }

                        // 移动，同方向不移动
                        var clientHeight = angular.element("#temp").height() - 34;
                        if (nextBlockBc && isUp != nextBlockBc.isUp) {
                            if (isUp) { // 移动下行
                                angular.element(".ttpv_table_scrollbar:eq(1)").animate(
                                    {scrollTop : nextIndex * 30 - clientHeight / 2}, 400);
                            } else { // 移动上行
                                angular.element(".ttpv_table_scrollbar:eq(0)").animate(
                                    {scrollTop : nextIndex * 30 - clientHeight / 2}, 400);
                            }
                        }

                    };

                    /**
                     * 刷新内部数据。
                     * @param ctrl 内部控制器对象（$saTimeTablePreviewCtrl）
                     * @private
                     */
                    var _fun_refreshInternalModel = function(ctrl) {
                        // 初始化内部数据
                        ctrl.internalBcModel = {
                            up_qdz_name : "", // 上行起点站名字
                            up_zdz_name : "", // 上行终点站名字
                            down_qdz_name : "", // 下行起点站名字
                            down_zdz_name : "", // 下行终点站名字
                            up_bc_list_asc : [], // 上行班次列表（按照发车时间升序）
                            down_bc_list_asc : [] // 下行班次列表（按照发车时间升序）
                        };
                        ctrl.internalLpBlockModel = {

                        };

                        // ngModel传入的数据
                        var dataSource = ctrl.ds.bcList;

                        // 构造上下行班次列表，并确定上下行的首发站点
                        angular.forEach(dataSource, function(bcObj) {
                            var _internalBcObj = {};
                            // 构造内部班次对象
                            _internalBcObj.lpName = bcObj.lp.lpName; // 路牌
                            _internalBcObj.fcsj = bcObj.fcsj; // 发车时间
                            _internalBcObj.ddsj = _fun_WrapTime(bcObj.fcsj).add(bcObj.bcsj, "m").format("HH:mm");
                            _internalBcObj.qdzName = bcObj.qdzName; // 起点站名字
                            _internalBcObj.zdzName = bcObj.zdzName; // 终点站名字
                            _internalBcObj.bcType = bcObj.bcType; // 班次类型
                            _internalBcObj.isTs = bcObj.isTS; // 是否停驶
                            _internalBcObj.isFb = bcObj.isFB; // 是否分班
                            _internalBcObj.remark = bcObj.remark; // 备注
                            _internalBcObj._fcno = bcObj.fcno; // 发车顺序号

                            if (bcObj.xlDir == "0") { // 上行
                                ctrl.internalBcModel.up_bc_list_asc.push(_internalBcObj);
                                // 确定起点站
                                if (ctrl.internalBcModel.up_qdz_name == "") {
                                    if (bcObj.bcType == "normal") {
                                        ctrl.internalBcModel.up_qdz_name = bcObj.qdzName;
                                    }
                                }
                                // 确定终点站
                                if (ctrl.internalBcModel.up_zdz_name == "") {
                                    if (bcObj.bcType == "normal") {
                                        ctrl.internalBcModel.up_zdz_name = bcObj.zdzName;
                                    }
                                }
                            }
                            if (bcObj.xlDir == "1") { // 下行
                                ctrl.internalBcModel.down_bc_list_asc.push(_internalBcObj);
                                // 确定起点站
                                if (ctrl.internalBcModel.down_qdz_name == "") {
                                    if (bcObj.bcType == "normal") {
                                        ctrl.internalBcModel.down_qdz_name = bcObj.qdzName;
                                    }
                                }
                                // 确定终点站
                                if (ctrl.internalBcModel.down_zdz_name == "") {
                                    if (bcObj.bcType == "normal") {
                                        ctrl.internalBcModel.down_zdz_name = bcObj.zdzName;
                                    }
                                }
                            }

                        });

                        // 发车时间升序排序上行班次
                        ctrl.internalBcModel.up_bc_list_asc.sort(function(a, b) {
                            var a_wrapTime = _fun_WrapTime(a.fcsj);
                            var b_wrapTime = _fun_WrapTime(b.fcsj);

                            // 判定如果发车时间是以00,01,02,03开头的，说明是下一天凌晨的班次，需要加1天判定
                            // TODO：以后要配合首班车的发车时间判定
                            if (a.fcsj.indexOf("00:") == 0 ||
                                a.fcsj.indexOf("01:") == 0 ||
                                a.fcsj.indexOf("02:") == 0) {
                                a_wrapTime.add(1, "day");
                            }
                            if (b.fcsj.indexOf("00:") == 0 ||
                                b.fcsj.indexOf("01:") == 0 ||
                                b.fcsj.indexOf("02:") == 0) {
                                b_wrapTime.add(1, "day");
                            }

                            if (a_wrapTime.isBefore(b_wrapTime)) {
                                return -1;
                            } else if (a_wrapTime.isAfter(b_wrapTime)) {
                                return 1;
                            } else {
                                return 0;
                            }

                        });
                        // 发车时间升序排序下行班次
                        ctrl.internalBcModel.down_bc_list_asc.sort(function(a, b) {
                            var a_wrapTime = _fun_WrapTime(a.fcsj);
                            var b_wrapTime = _fun_WrapTime(b.fcsj);

                            // 判定如果发车时间是以00,01,02,03开头的，说明是下一天凌晨的班次，需要加1天判定
                            // TODO：以后要配合首班车的发车时间判定
                            if (a.fcsj.indexOf("00:") == 0 ||
                                a.fcsj.indexOf("01:") == 0 ||
                                a.fcsj.indexOf("02:") == 0) {
                                a_wrapTime.add(1, "day");
                            }
                            if (b.fcsj.indexOf("00:") == 0 ||
                                b.fcsj.indexOf("01:") == 0 ||
                                b.fcsj.indexOf("02:") == 0) {
                                b_wrapTime.add(1, "day");
                            }

                            if (a_wrapTime.isBefore(b_wrapTime)) {
                                return -1;
                            } else if (a_wrapTime.isAfter(b_wrapTime)) {
                                return 1;
                            } else {
                                return 0;
                            }
                        });

                        // 构造路牌block车次链，按照发车顺序排序
                        angular.forEach(ctrl.internalBcModel.up_bc_list_asc, function(data, index) {
                            if (!ctrl.internalLpBlockModel[data.lpName]) {
                                ctrl.internalLpBlockModel[data.lpName] = [];
                            }
                            ctrl.internalLpBlockModel[data.lpName].push({
                                fcsj : data.fcsj,
                                isUp : true,
                                fcno : data._fcno,
                                index : index
                            });
                        });
                        angular.forEach(ctrl.internalBcModel.down_bc_list_asc, function(data, index) {
                            if (!ctrl.internalLpBlockModel[data.lpName]) {
                                ctrl.internalLpBlockModel[data.lpName] = [];
                            }
                            ctrl.internalLpBlockModel[data.lpName].push({
                                fcsj : data.fcsj,
                                isUp : false,
                                fcno : data._fcno,
                                index : index
                            });
                        });
                        angular.forEach(ctrl.internalLpBlockModel, function(value, key) {
                            value.sort(function (a, b) {
                                if (a.fcno < b.fcno) {
                                    return -1;
                                } else if (a.fcno > b.fcno) {
                                    return 1;
                                } else {
                                    return 0;
                                }
                            });
                        });


                    };

                    return {
                        pre : function(scope, element, attr) {
                            // TODO：
                        },
                        post : function(scope, element, attr) {
                            // 班次html点击事件
                            scope[ctrlAs].$$bcDD_Click = function(index, xlDir) {
                                _fun_bcDDViewMove(scope[ctrlAs], index, xlDir);
                            };

                            // 监控ngModel绑定的外部数据源的刷新状态变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].ds.refreshInfos;
                                },
                                function(newValue, oldValue) {
                                    if (newValue === undefined && oldValue === undefined) {
                                        return;
                                    }
                                    console.log("saTimetable2 refresh");
                                    _fun_refreshInternalModel(scope[ctrlAs]);
                                },
                                true
                            );
                        }
                    };
                }
            };
        }
    ]
);
/**
 * 滚动事件控制指令。
 */
angular.module('ScheduleApp').directive(
    'saTscrolly1',
    [
        function() {
            return {
                restrict: 'A',

                compile: function(tElem, tAttrs) {

                    return {
                        pre: function(scope, element, attr) {
                            // TODO：
                            //alert(element.find("#tooltipTest").html());
                            //$compile(element.find("#tooltipTest"))(scope);

                        },

                        post: function(scope, element, attr) {
                            //var head = element[0];

                            //console.log("llllllllload");
                            //console.log(element.name);

                            element.bind('scroll', function() {
                                //console.log("top=", angular.element(".tt_table_head").css("top"));
                                //console.log("left=", angular.element(".tt_table_head").css("left"));
                                //console.log("s top=" + element.scrollTop());

                                angular.element(".tt_table_head").css("top", element.scrollTop());
                                angular.element(".tt_table_head:eq(0)").css("left", element.scrollLeft());
                                angular.element(".tt_table_body:eq(0)").css("left", element.scrollLeft());

                            });
                        }

                    };
                }
            }
        }
    ]
);
/**
 * 滚动事件控制指令。
 */
angular.module('ScheduleApp').directive(
    'saTscrolly2',
    [
        function() {
            return {
                restrict: 'A',

                compile: function(tElem, tAttrs) {

                    return {
                        pre: function(scope, element, attr) {
                            // TODO：
                            //alert(element.find("#tooltipTest").html());
                            //$compile(element.find("#tooltipTest"))(scope);

                        },

                        post: function(scope, element, attr) {
                            //var head = element[0];

                            //console.log("llllllllload");
                            //console.log(element.name);

                            element.bind('scroll', function() {
                                //console.log("top=", angular.element(".tt_table_head").css("top"));
                                //console.log("left=", angular.element(".tt_table_head").css("left"));
                                //console.log("s top=" + element.scrollTop());

                                angular.element(attr.scrclass).css("top", element.scrollTop());
                                // angular.element(".tt_table_head:eq(0)").css("left", element.scrollLeft());
                                // angular.element(".tt_table_body:eq(0)").css("left", element.scrollLeft());

                            });
                        }

                    };
                }
            }
        }
    ]
);
/**
 * saOrderoption指令，搜索时的排序选项（在搜索时可以使用，通用的）
 * 属性如下：
 * name（必须）：控件的名字
 * columns（必须，独立作用域）：字段名字列表，格式：[{name:[字段名],desc:[字段描述]}...]
 * ordercolumns（必须，独立作用域）：字段排序列表，格式：{order: '字段1,字段2',direction: 'ASC,DESC'}
 */
angular.module('ScheduleApp').directive(
    'saOrderoption',
    [
        function() {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/queryOption/saOrderOptionTemplate.html',
                scope: {
                    columns: '=',
                    ordercolumns: '='
                },
                controllerAs: '$saOrderOptionCtrl',
                bindToController: true,
                controller: function() {
                    var self = this;

                    // 字段列表是否预载入
                    self.$$columns_loaded = false;
                    // 字段排序是否预载入
                    self.$$ordercolumns_loaded = false;


                    // 每组选项内部数据源
                    // 格式：[{column:[选中的字段名],dir:[ASC/DESC]}]
                    self.$$selectgroupds = [];

                    // TODO：选择事件

                    self.$$select_column_change = function() {
                        self.$$refresh_selectgroupds();
                    };

                    self.$$select_dir_change = function() {
                        self.$$refresh_selectgroupds();
                    };

                    self.$$add_option_click = function(index) {
                        self.$$selectgroupds.splice(index, 0, {
                            column: self.columns[0].name,
                            dir: "ASC"
                        });
                        self.$$refresh_selectgroupds();
                    };
                    self.$$del_option_click = function(index) {
                        self.$$selectgroupds.splice(index, 1);
                        self.$$refresh_selectgroupds();
                    };

                    // 刷新选项内部数据源
                    self.$$refresh_selectgroupds = function() {
                        if (!self.$$columns_loaded || !self.$$ordercolumns_loaded || self.columns.length == 0) {
                            // 没有载入完成，或者字段列表为空
                            return;
                        }

                        if (self.$$selectgroupds.length == 0) { // 默认添加一组排序
                            self.$$selectgroupds.push({
                                column: self.columns[0].name,
                                dir: "ASC"
                            });
                        }

                        // 重新计算ordercolumns

                        var aColumn = [];
                        var aDir = [];
                        for (var i = 0; i < self.$$selectgroupds.length; i++) {
                            aColumn.push(self.$$selectgroupds[i].column);
                            aDir.push(self.$$selectgroupds[i].dir);
                        }
                        if (self.ordercolumns) {
                            self.ordercolumns.order = aColumn.join(",");
                            self.ordercolumns.direction = aDir.join(",");
                        } else {
                            self.ordercolumns = {order: aColumn.join(","), direction: aDir.join(",")}
                        }

                    }
                },
                compile: function(tElem, tAttrs) {
                    // 获取所有属性，并验证
                    var $name_attr = tAttrs['name']; // 控件的名字
                    if (!$name_attr) {
                        throw "必须有名称属性";
                    }

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

                    // TODO：


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

                        },

                        post: function(scope, element, attr) {

                            //--------------------- 监控属性方法 -------------------//
                            // 监控字段名字列表
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].columns;
                                },
                                function(newValue, oldValue) {
                                    if (!scope[ctrlAs].$$columns_loaded) {
                                        // TODO：格式判定以后做，假设格式是对的


                                    }

                                    scope[ctrlAs].$$columns_loaded = true;
                                    scope[ctrlAs].$$refresh_selectgroupds();
                                },
                                true
                            );
                            // 监控字段排序列表
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].ordercolumns;
                                },
                                function(newValue, oldValue) {
                                    if (!scope[ctrlAs].$$ordercolumns_loaded) {
                                        if (newValue) {
                                            var aColumns = []; // 排序的字段
                                            var aDirs = []; // 排序字段对应的排序方向

                                            if (newValue.order) {
                                                aColumns = newValue.order.split(",");
                                            }
                                            if (newValue.direction) {
                                                aDirs = newValue.direction.split(",");
                                            }

                                            for (var i = 0; i < aColumns.length; i++) {
                                                if (i < aDirs.length) {
                                                    scope[ctrlAs].$$selectgroupds.push({
                                                        column: aColumns[i],
                                                        dir: aDirs[i]
                                                    });
                                                } else {
                                                    scope[ctrlAs].$$selectgroupds.push({
                                                        column: aColumns[i],
                                                        dir: 'ASC'
                                                    });
                                                }
                                            }
                                        }
                                    }
                                    scope[ctrlAs].$$ordercolumns_loaded = true;
                                    scope[ctrlAs].$$refresh_selectgroupds();

                                },
                                true
                            );
                        }

                    };
                }
            };
        }
    ]
);
/**
 * saScpdate指令（非通用指令，只在排班计划form中使用）。
 * 属性如下：
 * name（必须）：控件的名字
 * xlid（必须）：线路id
 * xlname（必须）：线路名字
 * from（必须）：独立作用域-绑定的开始时间属性名
 * to（必须）：独立作用域-绑定的结束时间属性名
 * error（必须）：独立作用域-绑定的错误描述属性名
 */
angular.module('ScheduleApp').directive(
    'saScpdate',
    [
        'SchedulePlanManageService_g',
        function(service) {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/scheduleplan/saScpdateTemplate.html',
                scope: {
                    from: '=',
                    to: '=',
                    xlid: '=',
                    xlname: '=',
                    ttinfonames: '=',
                    ttinfoids: '=',
                    error: '='
                },
                controllerAs: '$saScpdateCtrl',
                bindToController: true,
                controller: function() {
                    var self = this;

                    // 内部ng-model值，用于和required配对
                    self.$$internalmodel = undefined;

                    // 内部数据源（时刻表的一些信息）
                    self.$$ds = [];

                },
                compile: function(tElem, tAttrs) {
                    // 获取所有属性，并验证
                    var $name_attr = tAttrs['name']; // 控件的名字
                    if (!$name_attr) {
                        throw "必须有名称属性";
                    }

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

                    // 线路id
                    var xl_id = undefined;
                    // 线路名字
                    var xl_name = undefined;
                    // 开始时间
                    var from_date = undefined;
                    // 结束时间
                    var to_date = undefined;

                    // 内部添加required验证，将所有的错误应用到required验证上去
                    tElem.find("div").attr("required", "");

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

                        },

                        post: function(scope, element, attr) {
                            // 属性值
                            if ($name_attr) {
                                scope[ctrlAs]["$name_attr"] = $name_attr;
                            }

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

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


                            // 内部模型刷新
                            scope[ctrlAs].$$internal_model_refresh = function() {
                                if (!xl_id) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "线路必须选择";
                                    return;
                                }
                                if (!xl_name) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "线路必须选择";
                                    return;
                                }

                                if (!from_date) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "开始日期必须选择";
                                    return;
                                }
                                if (!to_date) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "结束日期必须选择";
                                    return;
                                }
                                if (from_date > to_date) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "开始日期必须在结束日期之前";
                                    return;
                                }

                                if (!scope[ctrlAs].$$ds || scope[ctrlAs].$$ds.length == 0) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "无可用时刻表";
                                }

                                var QClass = service.ttinfo;
                                var ttinfonames = [];
                                var ttinfoids = [];
                                QClass.val({xlid: xl_id, from: from_date, to: to_date},
                                    function(result) {
                                        scope[ctrlAs].$$ds = [];

                                        var errorTTInfos = 0;
                                        var errorLpCount = 0;

                                        if (result && result.data && result.data.infos && result.data.infos.length > 0) {
                                            angular.forEach(result.data.infos, function(obj) {
                                                scope[ctrlAs].$$ds.push({
                                                    xlid: xl_id,
                                                    ttid: obj.ttid,
                                                    xlname: xl_name,
                                                    ttname: obj.ttname,

                                                    allbc: obj.allbc,
                                                    inbc: obj.inbc,
                                                    outbc: obj.outbc,
                                                    yybc: obj.yybc,

                                                    errorbc: obj.errorbc,
                                                    errorlpCount: obj.errorlpCount,
                                                    errorlpInfo: obj.errorlpInfo,

                                                    lineVersion: obj.lineVersion

                                                });

                                                if (obj.errorbc > 0) {
                                                    errorTTInfos ++;
                                                } else if (obj.errorlpCount > 0) {
                                                    errorLpCount ++;
                                                } else {
                                                    ttinfonames.push(obj.ttname);
                                                    ttinfoids.push(obj.ttid);
                                                }
                                            });

                                            if (errorTTInfos > 0) {
                                                scope[ctrlAs].$$internalmodel = undefined;
                                                scope[ctrlAs].error = "时刻表有错误班次";
                                            } else if (errorLpCount > 0) {
                                                scope[ctrlAs].$$internalmodel = undefined;
                                                scope[ctrlAs].error = "时刻表有错误路牌";
                                            } else {
                                                scope[ctrlAs].$$internalmodel = "ok";
                                                scope[ctrlAs].ttinfonames = ttinfonames.join(",");
                                                scope[ctrlAs].ttinfoids = ttinfoids.join(",");
                                            }

                                        } else {
                                            scope[ctrlAs].$$internalmodel = undefined;
                                            scope[ctrlAs].error = "无可用时刻表";
                                        }
                                    },
                                    function() {
                                        scope[ctrlAs].$$internalmodel = undefined;
                                        scope[ctrlAs].error = "获取时刻表数据失败！";
                                    }
                                );


                                scope[ctrlAs].$$internalmodel = "ok";
                            };

                            scope[ctrlAs].$$internal_model_refresh(); // 初始执行

                            //--------------------- 监控属性方法 -------------------//
                            // 监控线路id模型值变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].xlid;
                                },
                                function(newValue, oldValue) {
                                    xl_id = newValue;
                                    scope[ctrlAs].$$internal_model_refresh();
                                }
                            );
                            // 监控线路name模型值变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].xlname;
                                },
                                function(newValue, oldValue) {
                                    xl_name = newValue;
                                    scope[ctrlAs].$$internal_model_refresh();
                                }
                            );

                            // 监控开始时间模型值变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].from;
                                },
                                function(newValue, oldValue) {
                                    from_date = newValue;
                                    scope[ctrlAs].$$internal_model_refresh();
                                }
                            );
                            // 监控结束时间模型值变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].to;
                                },
                                function(newValue, oldValue) {
                                    to_date = newValue;
                                    scope[ctrlAs].$$internal_model_refresh();
                                }
                            );

                        }
                    };
                }
            };
        }
    ]
);

/**
 * saSrule指令（非通用指令，只在排班计划form中使用）。
 * 属性如下：
 * name（必须）：控件的名字
 * xlid（必须）：线路id
 * from（必须）：独立作用域-绑定的开始时间属性名
 * to（必须）：独立作用域-绑定的结束时间属性名
 * error（必须）：独立作用域-绑定的错误描述属性名
 */
angular.module('ScheduleApp').directive(
    'saSrule',
    [
        'SchedulePlanManageService_g',
        function(service) {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/scheduleplan/saSruleTemplate.html',
                scope: {
                    from: '=',
                    to: '=',
                    xlid: '=',
                    error: '='
                },
                controllerAs: '$saSruleCtrl',
                bindToController: true,
                controller: function() {
                    var self = this;

                    // 内部ng-model值，用于和required配对
                    self.$$internalmodel = undefined;

                    // 内部数据源（时刻表的一些信息）
                    self.$$count = 0;
                    self.$$qyCount = 0;
                    self.$$qyErrorCount = 0;
                    self.$$errorInfos = [];

                },
                compile: function(tElem, tAttrs) {
                    // 获取所有属性，并验证
                    var $name_attr = tAttrs['name']; // 控件的名字
                    if (!$name_attr) {
                        throw "必须有名称属性";
                    }

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

                    // 线路id
                    var xl_id = undefined;
                    // 开始时间
                    var from_date = undefined;
                    // 结束时间
                    var to_date = undefined;

                    // 内部添加required验证，将所有的错误应用到required验证上去
                    tElem.find("div").attr("required", "");

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

                        },

                        post: function(scope, element, attr) {
                            // 属性值
                            if ($name_attr) {
                                scope[ctrlAs]["$name_attr"] = $name_attr;
                            }

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

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

                            // 内部模型刷新
                            scope[ctrlAs].$$internal_model_refresh = function() {
                                if (!xl_id) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "线路必须选择";
                                    return;
                                }
                                if (!from_date) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "开始日期必须选择";
                                    return;
                                }
                                if (!to_date) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "结束日期必须选择";
                                    return;
                                }
                                if (from_date > to_date) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "开始日期必须在结束日期之前";
                                    return;
                                }

                                scope[ctrlAs].$$count = 0;
                                scope[ctrlAs].$$qyCount = 0;
                                scope[ctrlAs].$$qyErrorCount = 0;
                                scope[ctrlAs].$$errorInfos = [];

                                if (scope[ctrlAs].$$qyCount == 0) {
                                    scope[ctrlAs].$$internalmodel = undefined;
                                    scope[ctrlAs].error = "无可启用的规则数";
                                }

                                var QClass = service.v_rules;
                                QClass.val({xlid: xl_id, from: from_date, to: to_date},
                                    function(result) {
                                        scope[ctrlAs].$$count = result.data.count;
                                        scope[ctrlAs].$$qyCount = result.data.qyCount;
                                        scope[ctrlAs].$$qyErrorCount = result.data.qyErrorCount;

                                        angular.forEach(result.data.errorInfos, function(obj) {
                                            scope[ctrlAs].$$errorInfos.push({
                                                ruleId: obj.ruleId,
                                                clZbh: obj.clZbh,
                                                qyrq: moment(obj.qyrq).format("YYYY年MM月DD日"),
                                                infos: obj.errorDescList.join("")
                                            });
                                        });

                                        if (scope[ctrlAs].$$qyErrorCount > 0) {
                                            scope[ctrlAs].$$internalmodel = undefined;
                                            scope[ctrlAs].error = "有错误的规则";
                                        } else {
                                            scope[ctrlAs].$$internalmodel = "ok";
                                            scope[ctrlAs].$$errorInfos = [];
                                        }
                                    },
                                    function() {
                                        scope[ctrlAs].$$internalmodel = undefined;
                                        scope[ctrlAs].error = "获取规则数据失败！";
                                    }
                                );

                                scope[ctrlAs].$$internalmodel = "ok";
                            };

                            scope[ctrlAs].$$internal_model_refresh(); // 初始执行

                            //--------------------- 监控属性方法 -------------------//
                            // 监控线路id模型值变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].xlid;
                                },
                                function(newValue, oldValue) {
                                    xl_id = newValue;
                                    scope[ctrlAs].$$internal_model_refresh();
                                }
                            );

                            // 监控开始时间模型值变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].from;
                                },
                                function(newValue, oldValue) {
                                    from_date = newValue;
                                    scope[ctrlAs].$$internal_model_refresh();
                                }
                            );
                            // 监控结束时间模型值变化
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].to;
                                },
                                function(newValue, oldValue) {
                                    to_date = newValue;
                                    scope[ctrlAs].$$internal_model_refresh();
                                }
                            );
                        }
                    };
                }
            };
        }
    ]
);
/**
 * saPlaninfoedit指令，排班明细编辑控件，用在调度执勤日报的修改功能
 * name（必须），控件的名字
 * ds，外部数据源
 * cl1，车辆1属性
 * cl2，车辆2属性
 * j1，驾驶员1属性
 * j2，驾驶员2属性
 * s1，售票员1属性
 * s2，售票员2属性
 */
angular.module('ScheduleApp').directive(
    'saPlaninfoedit',
    [
        function() {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/scheduleplan/saPlaninfoeditTemplate.html',
                scope: { // 独立作用域
                    ds: '=ngModel'
                },
                controllerAs: '$saPlanInfoEditCtrl',
                bindToController: true,
                controller: function() {
                    //var self = this;

                },

                compile: function(tElem, tAttrs) {
                    // 获取属性
                    var $attr_name = tAttrs["name"]; // 控件的名字
                    if (!$attr_name) {
                        throw {msg: "saPlaninfoedit指令name属性不能为空"};
                    }

                    // 内部controlAs名字
                    var ctrlAs = '$saPlanInfoEditCtrl';


                    // 内部变量，原始车辆，人员数据
                    var old_cl = {}; // key:{车辆id_车辆自编号}，value:所在list下标数组
                    var old_j = {}; // key:{驾驶员id_姓名_工号}, value:所在list下标数组
                    var old_s = {}; // key:{售票员id_姓名_工号}, value:所在list下标数组
                    var old_isfb = false; // 是否有分班
                    var old_isfb_index = 0; // 分班开始索引
                    var old_hasJCBC = false; // 是否有进场班次
                    var old_max_fcno = 0; // 最大发车顺序号
                    var old_firstJCBCFcno = 0; // 第一个进场班次发车顺序号
                    var old_half_bcs = 0; // 一般的班次数量

                    // 内部变量，变更的车辆，变更的人员
                    var new_cl1 = undefined; // 新的车辆1（车辆id_车辆自编号）
                    var new_cl2 = undefined; // 新的车辆2（车辆id_车辆自编号）
                    var new_j1 = undefined; // 新的驾驶员1（驾驶员id_姓名_工号）
                    var new_j2 = undefined; // 新的驾驶员2（驾驶员id_姓名_工号）
                    var new_s1 = undefined; // 新的售票员1（售票员id_姓名_工号）
                    var new_s2 = undefined; // 新的售票员2（售票员id_姓名_工号）

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

                        },
                        post: function(scope, element, attr) {

                            /**
                             * 刷新车辆数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_cl = function() {
                                if (new_cl1) {
                                    var new_cl1_id = new_cl1.split("_")[0];
                                    var new_cl1_zbh = new_cl1.split("_")[1];

                                    if (new_cl2) {
                                        var new_cl2_id = new_cl2.split("_")[0];
                                        var new_cl2_zbh = new_cl2.split("_")[1];

                                        if (old_isfb) { // 使用分班判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_isfb_index) {
                                                    obj.cl = new_cl1_id;
                                                    obj.clZbh = new_cl1_zbh;
                                                } else {
                                                    obj.cl = new_cl2_id;
                                                    obj.clZbh = new_cl2_zbh;
                                                }
                                            });

                                        } else if (old_hasJCBC && old_firstJCBCFcno < old_max_fcno) { // 使用进出场判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj) {
                                                if (obj.fcno <= old_firstJCBCFcno) {
                                                    obj.cl = new_cl1_id;
                                                    obj.clZbh = new_cl1_zbh;
                                                } else {
                                                    obj.cl = new_cl2_id;
                                                    obj.clZbh = new_cl2_zbh;
                                                }
                                            });
                                        } else { // 使用一半一半班次判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_half_bcs) {
                                                    obj.cl = new_cl1_id;
                                                    obj.clZbh = new_cl1_zbh;
                                                } else {
                                                    obj.cl = new_cl2_id;
                                                    obj.clZbh = new_cl2_zbh;
                                                }
                                            });
                                        }

                                    } else {
                                        angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                            obj.cl = new_cl1_id;
                                            obj.clZbh = new_cl1_zbh;
                                        });
                                    }

                                } else {
                                    // 使用旧的
                                    angular.forEach(old_cl, function(value, key) {
                                        angular.forEach(value, function(i) {
                                            scope[ctrlAs].ds[i].cl = key.split("_")[0];
                                            scope[ctrlAs].ds[i].clZbh = key.split("_")[1];
                                        });
                                    });
                                }
                            };

                            /**
                             * 刷新驾驶员数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_j = function() {
                                if (new_j1) {
                                    var new_j1_id = new_j1.split("_")[0];
                                    var new_j1_name = new_j1.split("_")[1];
                                    var new_j1_gh = new_j1.split("_")[2];
                                    if (new_j1_gh && new_j1_gh.indexOf("-") > 0) {
                                        new_j1_gh = new_j1_gh.substr(3); // 修正工号，把 55- 这种前缀去掉
                                    }

                                    if (new_j2) {
                                        var new_j2_id = new_j2.split("_")[0];
                                        var new_j2_name = new_j2.split("_")[1];
                                        var new_j2_gh = new_j2.split("_")[2];
                                        if (new_j2_gh && new_j2_gh.indexOf("-") > 0) {
                                            new_j2_gh = new_j2_gh.substr(3); // 修正工号，把 55- 这种前缀去掉
                                        }

                                        if (old_isfb) { // 使用分班判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_isfb_index) {
                                                    obj.j = new_j1_id;
                                                    obj.jGh = new_j1_gh;
                                                    obj.jName = new_j1_name;
                                                } else {
                                                    obj.j = new_j2_id;
                                                    obj.jGh = new_j2_gh;
                                                    obj.jName = new_j2_name;
                                                }
                                            });

                                        } else if (old_hasJCBC && old_firstJCBCFcno < old_max_fcno) { // 使用进出场判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj) {
                                                if (obj.fcno <= old_firstJCBCFcno) {
                                                    obj.j = new_j1_id;
                                                    obj.jGh = new_j1_gh;
                                                    obj.jName = new_j1_name;
                                                } else {
                                                    obj.j = new_j2_id;
                                                    obj.jGh = new_j2_gh;
                                                    obj.jName = new_j2_name;
                                                }
                                            });
                                        } else { // 使用一半一半班次判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_half_bcs) {
                                                    obj.j = new_j1_id;
                                                    obj.jGh = new_j1_gh;
                                                    obj.jName = new_j1_name;
                                                } else {
                                                    obj.j = new_j2_id;
                                                    obj.jGh = new_j2_gh;
                                                    obj.jName = new_j2_name;
                                                }
                                            });
                                        }

                                    } else {
                                        angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                            obj.j = new_j1_id;
                                            obj.jGh = new_j1_gh;
                                            obj.jName = new_j1_name;
                                        });
                                    }

                                } else {
                                    // 使用旧的
                                    angular.forEach(old_j, function(value, key) {
                                        angular.forEach(value, function(i) {
                                            scope[ctrlAs].ds[i].j = key.split("_")[0];
                                            scope[ctrlAs].ds[i].jName = key.split("_")[1];
                                            scope[ctrlAs].ds[i].jGh = key.split("_")[2];
                                        });
                                    });
                                }
                            };
                            /**
                             * 刷新售票员数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_s = function() {
                                if (new_s1) {
                                    var new_s1_id = new_s1.split("_")[0];
                                    var new_s1_name = new_s1.split("_")[1];
                                    var new_s1_gh = new_s1.split("_")[2];
                                    if (new_s1_gh && new_s1_gh.indexOf("-") > 0) { // 修正工号，吧 55- 这种前缀去掉
                                        new_s1_gh = new_s1_gh.substr(3);
                                    }

                                    if (new_s2) {
                                        var new_s2_id = new_s2.split("_")[0];
                                        var new_s2_name = new_s2.split("_")[1];
                                        var new_s2_gh = new_s2.split("_")[2];
                                        if (new_s2_gh && new_s2_gh.indexOf("-") > 0) { // 修正工号，吧 55- 这种前缀去掉
                                            new_s2_gh = new_s2_gh.substr(3);
                                        }

                                        if (old_isfb) { // 使用分班判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_isfb_index) {
                                                    obj.s = new_s1_id;

                                                    obj.sGh = new_s1_gh;
                                                    obj.sName = new_s1_name;
                                                } else {
                                                    obj.s = new_s2_id;
                                                    obj.sGh = new_s2_gh;
                                                    obj.sName = new_s2_name;
                                                }
                                            });

                                        } else if (old_hasJCBC && old_firstJCBCFcno < old_max_fcno) { // 使用进出场判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj) {
                                                if (obj.fcno <= old_firstJCBCFcno) {
                                                    obj.s = new_s1_id;
                                                    obj.sGh = new_s1_gh;
                                                    obj.sName = new_s1_name;
                                                } else {
                                                    obj.s = new_s2_id;
                                                    obj.sGh = new_s2_gh;
                                                    obj.sName = new_s2_name;
                                                }
                                            });
                                        } else { // 使用一半一半班次判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_half_bcs) {
                                                    obj.s = new_s1_id;
                                                    obj.sGh = new_s1_gh;
                                                    obj.sName = new_s1_name;
                                                } else {
                                                    obj.s = new_s2_id;
                                                    obj.sGh = new_s2_gh;
                                                    obj.sName = new_s2_name;
                                                }
                                            });
                                        }

                                    } else {
                                        angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                            obj.s = new_s1_id;
                                            obj.sGh = new_s1_gh;
                                            obj.sName = new_s1_name;
                                        });
                                    }

                                } else {
                                    // 先清空
                                    angular.forEach(scope[ctrlAs].ds, function(obj) {
                                        obj.s = undefined;
                                        obj.sGh = undefined;
                                        obj.sName = undefined;
                                    });

                                    // 使用旧的
                                    angular.forEach(old_s, function(value, key) {
                                        angular.forEach(value, function(i) {
                                            scope[ctrlAs].ds[i].s = key.split("_")[0];
                                            scope[ctrlAs].ds[i].sName = key.split("_")[1];
                                            scope[ctrlAs].ds[i].sGh = key.split("_")[2];
                                        });
                                    });
                                }
                            };

                            /**
                             * 刷新内部数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata = function() {
                                // 更新车辆
                                scope[ctrlAs].$$internal_refresh_dsdata_cl();

                                // 更新驾驶员
                                scope[ctrlAs].$$internal_refresh_dsdata_j();

                                // 更新售票员
                                scope[ctrlAs].$$internal_refresh_dsdata_s();
                            };

                            // -------------- 监控function ---------------//
                            attr.$observe('cl1', function(value) {
                                if (value && value != "") {
                                    var obj = JSON.parse(value);
                                    if (obj.id && obj.zbh) {
                                        new_cl1 = obj.id + "_" + obj.zbh;
                                    } else {
                                        new_cl1 = undefined;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata();
                                }
                            });

                            attr.$observe('cl2', function(value) {
                                if (value && value != "") {
                                    var obj = JSON.parse(value);
                                    if (obj.id && obj.zbh) {
                                        new_cl2 = obj.id + "_" + obj.zbh;
                                    } else {
                                        new_cl2 = undefined;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata();
                                }
                            });

                            attr.$observe('j1', function(value) {
                                if (value && value != "") {
                                    var obj = JSON.parse(value);
                                    if (obj.id && obj.name && obj.jobCode) {
                                        new_j1 = obj.id + "_" + obj.name + "_" + obj.jobCode;
                                    } else {
                                        new_j1 = undefined;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata();
                                }
                            });

                            attr.$observe('j2', function(value) {
                                if (value && value != "") {
                                    var obj = JSON.parse(value);
                                    if (obj.id && obj.name && obj.jobCode) {
                                        new_j2 = obj.id + "_" + obj.name + "_" + obj.jobCode;
                                    } else {
                                        new_j2 = undefined;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata();
                                }
                            });

                            attr.$observe('s1', function(value) {
                                if (value && value != "") {
                                    var obj = JSON.parse(value);
                                    if (obj.id && obj.name && obj.jobCode) {
                                        new_s1 = obj.id + "_" + obj.name + "_" + obj.jobCode;
                                    } else {
                                        new_s1 = undefined;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata();
                                }
                            });

                            attr.$observe('s2', function(value) {
                                if (value && value != "") {
                                    var obj = JSON.parse(value);
                                    if (obj.id && obj.name && obj.jobCode) {
                                        new_s2 = obj.id + "_" + obj.name + "_" + obj.jobCode;
                                    } else {
                                        new_s2 = undefined;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata();
                                }
                            });

                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].ds;
                                },
                                function(newValue, oldValue) {
                                    if (newValue && newValue.length > 0) {

                                        var j1 = newValue[0].j;

                                        angular.forEach(newValue, function(obj, index) {
                                            var k1 = obj.cl + "_" + obj.clZbh;
                                            var k2 = !obj.j? undefined: obj.j + "_" + obj.jName + "_" + obj.jGh;
                                            var k3 = !obj.s? undefined: obj.s + "_" + obj.sName + "_" + obj.sGh;

                                            if (!old_cl[k1]) {
                                                old_cl[k1] = [];
                                            }
                                            if (!old_j[k2] && k2) {
                                                old_j[k2] = [];
                                            }
                                            if (!old_s[k3] && k3) {
                                                old_s[k3] = [];
                                            }

                                            // 闭包
                                            (function(i) {
                                                old_cl[k1].push(i);
                                                if (k2) {
                                                    old_j[k2].push(i);
                                                }
                                                if (k3) {
                                                    old_s[k3].push(i);
                                                }
                                            })(index);

                                            // 判断是否分班
                                            if (j1 != obj.j && !old_isfb) {
                                                old_isfb = true;
                                                old_isfb_index = index;
                                            }

                                            // 判断进出场
                                            if (obj.bcType == 'in' && !old_hasJCBC) {
                                                old_hasJCBC = true;
                                                old_firstJCBCFcno = obj.fcno;
                                            }
                                        });

                                        old_max_fcno = newValue[newValue.length - 1].fcno;
                                        old_half_bcs = newValue.length / 2;

                                        // 可以用resource封装一下
                                        // TODO：
                                    }
                                }
                            );
                        }
                    }
                }
            };
        }
    ]
);
/**
 * saPlaninfoedit2指令，排班明细编辑控件，用在调度执勤日报的修改功能
 * name（必须），控件的名字
 * ds，外部数据源
 * fd, 表单数据源
 */
angular.module('ScheduleApp').directive(
    'saPlaninfoedit2',
    [
        function() {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/scheduleplan/saPlaninfoeditTemplate.html',
                scope: { // 独立作用域
                    ds: '=ngModel', // 时刻明细数据源头
                    fd: '=formData' // 表单数据源（车辆、驾驶员、售票员信息）
                },
                controllerAs: '$saPlanInfoEditCtrl',
                bindToController: true,
                controller: function() {
                    //var self = this;

                },

                compile: function(tElem, tAttrs) {
                    // 获取属性
                    var $attr_name = tAttrs["name"]; // 控件的名字
                    if (!$attr_name) {
                        throw {msg: "saPlaninfoedit2指令name属性不能为空"};
                    }

                    // 内部controlAs名字
                    var ctrlAs = '$saPlanInfoEditCtrl';


                    // 内部变量，原始车辆，人员数据
                    var old_cl = {}; // key:{车辆id_车辆自编号}，value:所在list下标数组
                    var old_j = {}; // key:{驾驶员id_姓名_工号}, value:所在list下标数组
                    var old_s = {}; // key:{售票员id_姓名_工号}, value:所在list下标数组
                    var old_isfb = false; // 是否有分班
                    var old_isfb_index = 0; // 分班开始索引
                    var old_hasJCBC = false; // 是否有进场班次
                    var old_max_fcno = 0; // 最大发车顺序号
                    var old_firstJCBCFcno = 0; // 第一个进场班次发车顺序号
                    var old_half_bcs = 0; // 一般的班次数量
                    var old_ddreason = {}; // key:{调度原因}, value:所在list下标数组
                    var old_dddesc = {}; // key:{调度描述}, value:所在list下标数组

                    // 内部变量，变更的车辆，变更的人员
                    var new_cl1 = undefined; // 新的车辆1（车辆id_车辆自编号）
                    var new_cl2 = undefined; // 新的车辆2（车辆id_车辆自编号）
                    var new_j1 = undefined; // 新的驾驶员1（驾驶员id_姓名_工号）
                    var new_j2 = undefined; // 新的驾驶员2（驾驶员id_姓名_工号）
                    var new_s1 = undefined; // 新的售票员1（售票员id_姓名_工号）
                    var new_s2 = undefined; // 新的售票员2（售票员id_姓名_工号）
                    var new_ddreason = undefined; // 调度原因
                    var new_dddesc = undefined; // 调度描述

                    // 表单值，被赋值的次数
                    var form_data_assign_count = { // 大于1表示已经初始化过了
                        cl1 : -1,
                        cl2 : -1,
                        j1 : -1,
                        j2 : -1,
                        j3 : -1,
                        s1 : -1,
                        s2 : -1,
                        s3 : -1
                    };

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

                        },
                        post: function(scope, element, attr) {

                            /**
                             * 刷新调度原因数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_ddreason = function() {
                                if (new_ddreason) {
                                    angular.forEach(scope[ctrlAs].ds, function(obj) {
                                        obj.modifyReason = new_ddreason;
                                    });
                                } else {
                                    // 清空，不使用旧的
                                    angular.forEach(old_ddreason, function(value, key) {
                                        angular.forEach(value, function(i) {
                                            scope[ctrlAs].ds[i].modifyReason = undefined;
                                        });
                                    });
                                }
                            };

                            /**
                             * 刷新调度描述数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_dddesc = function() {
                                if (new_dddesc) {
                                    angular.forEach(scope[ctrlAs].ds, function(obj) {
                                        obj.modifyRemark = new_dddesc;
                                    });
                                } else {
                                    // 清空，不使用旧的
                                    angular.forEach(old_dddesc, function(value, key) {
                                        angular.forEach(value, function(i) {
                                            scope[ctrlAs].ds[i].modifyRemark = undefined;
                                        });
                                    });
                                }
                            };

                            /**
                             * 刷新车辆数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_cl = function() {
                                if (new_cl1) {
                                    var new_cl1_id = new_cl1.split("_")[0];
                                    var new_cl1_zbh = new_cl1.split("_")[1];

                                    if (new_cl2) {
                                        var new_cl2_id = new_cl2.split("_")[0];
                                        var new_cl2_zbh = new_cl2.split("_")[1];

                                        if (old_isfb) { // 使用分班判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_isfb_index) {
                                                    obj.cl = new_cl1_id;
                                                    obj.clZbh = new_cl1_zbh;
                                                } else {
                                                    obj.cl = new_cl2_id;
                                                    obj.clZbh = new_cl2_zbh;
                                                }
                                            });

                                        } else if (old_hasJCBC && old_firstJCBCFcno < old_max_fcno) { // 使用进出场判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj) {
                                                if (obj.fcno <= old_firstJCBCFcno) {
                                                    obj.cl = new_cl1_id;
                                                    obj.clZbh = new_cl1_zbh;
                                                } else {
                                                    obj.cl = new_cl2_id;
                                                    obj.clZbh = new_cl2_zbh;
                                                }
                                            });
                                        } else { // 使用一半一半班次判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_half_bcs) {
                                                    obj.cl = new_cl1_id;
                                                    obj.clZbh = new_cl1_zbh;
                                                } else {
                                                    obj.cl = new_cl2_id;
                                                    obj.clZbh = new_cl2_zbh;
                                                }
                                            });
                                        }

                                    } else {
                                        angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                            obj.cl = new_cl1_id;
                                            obj.clZbh = new_cl1_zbh;
                                        });
                                    }

                                } else {
                                    // 清空，不使用旧的
                                    angular.forEach(old_cl, function(value, key) {
                                        angular.forEach(value, function(i) {
                                            //scope[ctrlAs].ds[i].cl = key.split("_")[0];
                                            //scope[ctrlAs].ds[i].clZbh = key.split("_")[1];
                                            scope[ctrlAs].ds[i].cl = undefined;
                                            scope[ctrlAs].ds[i].clZbh = undefined;
                                        });
                                    });
                                }
                            };

                            /**
                             * 刷新驾驶员数据。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_j = function() {
                                if (new_j1) {
                                    var new_j1_id = new_j1.split("_")[0];
                                    var new_j1_name = new_j1.split("_")[1];
                                    var new_j1_gh = new_j1.split("_")[2];
                                    if (new_j1_gh && new_j1_gh.indexOf("-") > 0) {
                                        new_j1_gh = new_j1_gh.substr(3); // 修正工号，把 55- 这种前缀去掉
                                    }

                                    if (new_j2) {
                                        var new_j2_id = new_j2.split("_")[0];
                                        var new_j2_name = new_j2.split("_")[1];
                                        var new_j2_gh = new_j2.split("_")[2];
                                        if (new_j2_gh && new_j2_gh.indexOf("-") > 0) {
                                            new_j2_gh = new_j2_gh.substr(3); // 修正工号，把 55- 这种前缀去掉
                                        }

                                        if (old_isfb) { // 使用分班判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_isfb_index) {
                                                    obj.j = new_j1_id;
                                                    obj.jGh = new_j1_gh;
                                                    obj.jName = new_j1_name;
                                                } else {
                                                    obj.j = new_j2_id;
                                                    obj.jGh = new_j2_gh;
                                                    obj.jName = new_j2_name;
                                                }
                                            });

                                        } else if (old_hasJCBC && old_firstJCBCFcno < old_max_fcno) { // 使用进出场判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj) {
                                                if (obj.fcno <= old_firstJCBCFcno) {
                                                    obj.j = new_j1_id;
                                                    obj.jGh = new_j1_gh;
                                                    obj.jName = new_j1_name;
                                                } else {
                                                    obj.j = new_j2_id;
                                                    obj.jGh = new_j2_gh;
                                                    obj.jName = new_j2_name;
                                                }
                                            });
                                        } else { // 使用一半一半班次判定
                                            angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                                if (index < old_half_bcs) {
                                                    obj.j = new_j1_id;
                                                    obj.jGh = new_j1_gh;
                                                    obj.jName = new_j1_name;
                                                } else {
                                                    obj.j = new_j2_id;
                                                    obj.jGh = new_j2_gh;
                                                    obj.jName = new_j2_name;
                                                }
                                            });
                                        }

                                    } else {
                                        angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                            obj.j = new_j1_id;
                                            obj.jGh = new_j1_gh;
                                            obj.jName = new_j1_name;
                                        });
                                    }

                                } else {
                                    // 清空，不使用使用旧的
                                    angular.forEach(old_j, function(value, key) {
                                        angular.forEach(value, function(i) {
                                            //scope[ctrlAs].ds[i].j = key.split("_")[0];
                                            //scope[ctrlAs].ds[i].jName = key.split("_")[1];
                                            //scope[ctrlAs].ds[i].jGh = key.split("_")[2];
                                            scope[ctrlAs].ds[i].j = undefined;
                                            scope[ctrlAs].ds[i].jName = undefined;
                                            scope[ctrlAs].ds[i].jGh = undefined;
                                        });
                                    });
                                }
                            };

                            /**
                             * 刷新售票员数据（和驾驶员配对的，有驾驶员，才有售票员）。
                             */
                            scope[ctrlAs].$$internal_refresh_dsdata_s = function() {
                                var j_id = undefined;
                                var s_id = undefined;
                                var s_gh = undefined;
                                var s_name = undefined;

                                if (new_j1) {
                                    j_id = new_j1.split("_")[0];
                                    if (new_s1) {
                                        s_id = new_s1.split("_")[0];
                                        s_name = new_s1.split("_")[1];
                                        s_gh = new_s1.split("_")[2];
                                        if (s_gh && s_gh.indexOf("-") > 0) { // 修正工号，把 55- 这种前缀去掉
                                            s_gh = s_gh.substr(3);
                                        }
                                    } else {
                                        s_id = undefined;
                                        s_gh = undefined;
                                        s_name = undefined
                                    }
                                    angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                        if (obj.j == j_id) {
                                            obj.s = s_id;
                                            obj.sGh = s_gh;
                                            obj.sName = s_name;
                                        }
                                    });
                                }
                                if (new_j2) {
                                    j_id = new_j2.split("_")[0];
                                    if (new_s2) {
                                        s_id = new_s2.split("_")[0];
                                        s_name = new_s2.split("_")[1];
                                        s_gh = new_s2.split("_")[2];
                                        if (s_gh && s_gh.indexOf("-") > 0) { // 修正工号，把 55- 这种前缀去掉
                                            s_gh = s_gh.substr(3);
                                        }
                                    } else {
                                        s_id = undefined;
                                        s_gh = undefined;
                                        s_name = undefined
                                    }

                                    angular.forEach(scope[ctrlAs].ds, function(obj, index) {
                                        if (obj.j == j_id) {
                                            obj.s = s_id;
                                            obj.sGh = s_gh;
                                            obj.sName = s_name;
                                        }
                                    });
                                }
                            };

                            //-------------- 监控调度原因的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.ddr;
                                },
                                function(newValue, oldValue) {
                                    if (newValue || newValue == 0) {
                                        new_ddreason = newValue;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata_ddreason();
                                },
                                true
                            );

                            //-------------- 监控调度描述的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.ddrdesc;
                                },
                                function(newValue, oldValue) {
                                    if (newValue || newValue == 0) {
                                        new_dddesc = newValue;
                                    }
                                    scope[ctrlAs].$$internal_refresh_dsdata_dddesc();
                                },
                                true
                            );


                            //-------------- 监控表单车辆1的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.cl1;
                                },
                                function(newValue, oldValue) {
                                    if (form_data_assign_count.cl1 > 2) {
                                        if (newValue.id) {
                                            if (newValue.id && newValue.zbh) {
                                                new_cl1 = newValue.id + "_" + newValue.zbh;
                                            } else {
                                                new_cl1 = undefined;
                                            }
                                        } else {
                                            new_cl1 = undefined;
                                        }
                                        scope[ctrlAs].$$internal_refresh_dsdata_cl();
                                    }

                                    form_data_assign_count.cl1 ++;
                                },
                                true
                            );

                            //-------------- 监控表单车辆2的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.cl2;
                                },
                                function(newValue, oldValue) {
                                    if (form_data_assign_count.cl2 > 2) {
                                        if (newValue.id) {
                                            if (newValue.id && newValue.zbh) {
                                                new_cl2 = newValue.id + "_" + newValue.zbh;
                                            } else {
                                                new_cl2 = undefined;
                                            }
                                        } else {
                                            new_cl2 = undefined;
                                        }
                                        scope[ctrlAs].$$internal_refresh_dsdata_cl();
                                    }

                                    form_data_assign_count.cl2 ++;
                                },
                                true
                            );

                            //-------------- 监控表单驾驶员1的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.j1;
                                },
                                function(newValue, oldValue) {
                                    if (form_data_assign_count.j1 > 2) {
                                        if (newValue.id) {
                                            if (newValue.id && newValue.name && newValue.jobCode) {
                                                new_j1 = newValue.id + "_" + newValue.name + "_" + newValue.jobCode;
                                            } else {
                                                new_j1 = undefined;
                                            }
                                        } else {
                                            new_j1 = undefined;
                                        }

                                        scope[ctrlAs].$$internal_refresh_dsdata_j();
                                        scope[ctrlAs].$$internal_refresh_dsdata_s();
                                    }

                                    form_data_assign_count.j1 ++;
                                },
                                true
                            );

                            //-------------- 监控表单售票员1的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.s1;
                                },
                                function(newValue, oldValue) {
                                    if (form_data_assign_count.s1 > 2) {
                                        if (newValue.id) {
                                            if (newValue.id && newValue.name && newValue.jobCode) {
                                                new_s1 = newValue.id + "_" + newValue.name + "_" + newValue.jobCode;
                                            } else {
                                                new_s1 = undefined;
                                            }
                                        } else {
                                            new_s1 = undefined;
                                        }

                                        scope[ctrlAs].$$internal_refresh_dsdata_j();
                                        scope[ctrlAs].$$internal_refresh_dsdata_s();
                                    }

                                    form_data_assign_count.s1 ++;
                                },
                                true
                            );

                            //-------------- 监控表单驾驶员2的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.j2;
                                },
                                function(newValue, oldValue) {
                                    if (form_data_assign_count.j2 > 2) {
                                        if (newValue.id) {
                                            if (newValue.id && newValue.name && newValue.jobCode) {
                                                new_j2 = newValue.id + "_" + newValue.name + "_" + newValue.jobCode;
                                            } else {
                                                new_j2 = undefined;
                                            }
                                        } else {
                                            new_j2 = undefined;
                                        }

                                        scope[ctrlAs].$$internal_refresh_dsdata_j();
                                        scope[ctrlAs].$$internal_refresh_dsdata_s();
                                    }

                                    form_data_assign_count.j2 ++;
                                },
                                true
                            );

                            //-------------- 监控表单售票员2的变化 ----------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].fd.s2;
                                },
                                function(newValue, oldValue) {
                                    if (form_data_assign_count.s2 > 2) {
                                        if (newValue && newValue.id) {
                                            if (newValue.id && newValue.name && newValue.jobCode) {
                                                new_s2 = newValue.id + "_" + newValue.name + "_" + newValue.jobCode;
                                            } else {
                                                new_s2 = undefined;
                                            }
                                        } else {
                                            new_s2 = undefined;
                                        }

                                        scope[ctrlAs].$$internal_refresh_dsdata_j();
                                        scope[ctrlAs].$$internal_refresh_dsdata_s();
                                    }

                                    form_data_assign_count.s2 ++;
                                },
                                true
                            );

                            //-------------------- 监控ds的变化，更新数据源，初始化formdata的数据 ---------------//
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].ds;
                                },
                                function(newValue, oldValue) {
                                    if (newValue && newValue.length > 0) {
                                        var j1 = newValue[0].j;

                                        var cl_idFlags = []; // 车辆idFlags数组（有顺序）
                                        var j_s_idFlags = []; // 驾驶员idFlags，售票员idFlags，[{j:idFlag,s:idFlag},...]（有顺序）
                                        var addreason = []; // 营运调度的原因
                                        var adddesc = []; // 营运导读的备注
                                        var isRepeat = false;
                                        var i = 0;

                                        angular.forEach(newValue, function(obj, index) {
                                            var k1 = obj.cl + "_" + obj.clZbh;
                                            var k2 = !obj.j? undefined: obj.j + "_" + obj.jName + "_" + obj.jGh;
                                            var k3 = !obj.s? undefined: obj.s + "_" + obj.sName + "_" + obj.sGh;

                                            if (!old_cl[k1]) {
                                                old_cl[k1] = [];
                                            }
                                            if (!old_j[k2] && k2) {
                                                old_j[k2] = [];
                                            }
                                            if (!old_s[k3] && k3) {
                                                old_s[k3] = [];
                                            }

                                            var dd4 = obj.modifyReason == null || obj.modifyReason == undefined ? undefined :
                                                obj.modifyReason;
                                            var dd5 = obj.modifyRemark == null || obj.modifyRemark == undefined ? undefined :
                                                obj.modifyRemark;

                                            if (!old_ddreason[dd4] && dd4) {
                                                old_ddreason[dd4] = [];
                                            }
                                            if (!old_dddesc[dd5] && dd5) {
                                                old_dddesc[dd5] = [];
                                            }

                                            // 闭包
                                            (function(i) {
                                                old_cl[k1].push(i);
                                                if (k2) {
                                                    old_j[k2].push(i);
                                                }
                                                if (k3) {
                                                    old_s[k3].push(i);
                                                }
                                                if (dd4) {
                                                    old_ddreason[dd4].push(i);
                                                }
                                                if (dd5) {
                                                    old_dddesc[dd5].push(i);
                                                }
                                            })(index);

                                            // 判断是否分班
                                            if (j1 != obj.j && !old_isfb) {
                                                old_isfb = true;
                                                old_isfb_index = index;
                                            }

                                            // 判断进出场
                                            if (obj.bcType == 'in' && !old_hasJCBC) {
                                                old_hasJCBC = true;
                                                old_firstJCBCFcno = obj.fcno;
                                            }

                                            //-------------- formdata用数据处理 -------------//
                                            // 车辆处理
                                            isRepeat = false;
                                            if (obj.cl) {
                                                for (i = 0; i < cl_idFlags.length; i++) {
                                                    if (cl_idFlags[i] == (obj.cl + "_" + obj.clZbh)) {
                                                        isRepeat = true;
                                                        break;
                                                    }
                                                }
                                                if (!isRepeat) {
                                                    cl_idFlags.push(obj.cl + "_" + obj.clZbh);
                                                }
                                            }

                                            // 人员处理（以驾驶员id为主，没有的话，售票员不管了）
                                            isRepeat = false;
                                            if (obj.j) {
                                                for (i = 0; i < j_s_idFlags.length; i++) {
                                                    if (j_s_idFlags[i].j == (obj.j + "_" + obj.jName + "_" + obj.jGh)) {
                                                        isRepeat = true;
                                                        break;
                                                    }
                                                }
                                                if (!isRepeat) {
                                                    j_s_idFlags.push({
                                                        j: obj.j + "_" + obj.jName + "_" + obj.jGh,
                                                        s: !obj.s? undefined: (obj.s + "_" + obj.sName + "_" + obj.sGh)
                                                    });
                                                }
                                            }

                                            // 调度原因处理
                                            isRepeat = false;
                                            if (obj.modifyReason || obj.modifyReason == 0) {
                                                for (i = 0; i < addreason.length; i++) {
                                                    if (addreason[i] == obj.modifyReason) {
                                                        isRepeat = true;
                                                        break;
                                                    }
                                                }
                                                if (!isRepeat) {
                                                    addreason.push(obj.modifyReason);
                                                }
                                            }

                                            // 调整备注处理
                                            isRepeat = false;
                                            if (obj.modifyRemark && obj.modifyRemark != "") {
                                                for (i = 0; i < adddesc.length; i++) {
                                                    if (adddesc[i] == obj.modifyRemark) {
                                                        isRepeat = true;
                                                        break;
                                                    }
                                                }
                                                if (!isRepeat) {
                                                    adddesc.push(obj.modifyRemark);
                                                }
                                            }

                                        });

                                        old_max_fcno = newValue[newValue.length - 1].fcno;
                                        old_half_bcs = newValue.length / 2;

                                        // 更新formdata
                                        for (i = 0; i < cl_idFlags.length; i++) { // 车辆更新前两辆
                                            if (i == 0) { // 第一组车
                                                scope[ctrlAs].fd["cl1"].id = cl_idFlags[i].split("_")[0];
                                                new_cl1 = cl_idFlags[i];
                                            } else if (i == 1) { // 第二组车
                                                scope[ctrlAs].fd["cl2"].id = cl_idFlags[i].split("_")[0];
                                                new_cl2 = cl_idFlags[i];
                                            } else { // 第三组及以上车全部忽略
                                                break;
                                            }
                                        }
                                        for (i = 0; i < j_s_idFlags.length; i++) { // 人员更新
                                            if (i == 0) { // 第一组人员
                                                scope[ctrlAs].fd["j1"].id = j_s_idFlags[i].j.split("_")[0];
                                                scope[ctrlAs].fd["s1"].id = j_s_idFlags[i].s && j_s_idFlags[i].s.split("_")[0];
                                                new_j1 = j_s_idFlags[i].j;
                                                new_s1 = j_s_idFlags[i].s;

                                            } else if (i == 1) { // 第二组人员
                                                scope[ctrlAs].fd["j2"].id = j_s_idFlags[i].j.split("_")[0];
                                                scope[ctrlAs].fd["s2"].id = j_s_idFlags[i].s && j_s_idFlags[i].s.split("_")[0];
                                                new_j2 = j_s_idFlags[i].j;
                                                new_s2 = j_s_idFlags[i].s;
                                            } else { // 第三组及以上全部忽律
                                                break;
                                            }
                                        }
                                        // 更新form_data_assign_count，有值设置成2，没值设置成3，表示已经从ds处初始化完毕
                                        if (new_cl1) {
                                            form_data_assign_count["cl1"] = 2;
                                        } else {
                                            form_data_assign_count["cl1"] = 3;
                                        }
                                        if (new_cl2) {
                                            form_data_assign_count["cl2"] = 2;
                                        } else {
                                            form_data_assign_count["cl2"] = 3;
                                        }
                                        if (new_j1) {
                                            form_data_assign_count["j1"] = 2;
                                        } else {
                                            form_data_assign_count["j1"] = 3;
                                        }
                                        if (new_j2) {
                                            form_data_assign_count["j2"] = 2;
                                        } else {
                                            form_data_assign_count["j2"] = 3;
                                        }
                                        if (new_s1) {
                                            form_data_assign_count["s1"] = 2;
                                        } else {
                                            form_data_assign_count["s1"] = 3;
                                        }
                                        if (new_s2) {
                                            form_data_assign_count["s2"] = 2;
                                        } else {
                                            form_data_assign_count["s2"] = 3;
                                        }


                                        for (i = 0; i < addreason.length; i++) { // 调度原因更新
                                            if (i > 1) { // 有多个，只更新第一个
                                                break;
                                            } else {
                                                scope[ctrlAs].fd.ddr = addreason[i];
                                            }
                                        }
                                        for (i = 0; i < adddesc.length; i++) {
                                            if (i > 1) { // 有多个，只更新第一个
                                                break;
                                            } else {
                                                scope[ctrlAs].fd.ddrdesc = adddesc[i];
                                            }
                                        }
                                    }
                                }
                            );
                        }
                    }
                }
            };
        }
    ]
);
/**
 * saPlanInfoView指令，排班明细显示指令（以类似时刻表的形式显示）
 */
angular.module('ScheduleApp').directive(
    'saPlaninfoview',
    [
        '$compile',
        '$window',
        '$timeout',
        function($compile, $window, $timeout) {
            return {
                restrict: 'E',
                templateUrl: '/pages/scheduleApp/module/common/dts2/scheduleplan/saPlanInfoViewTemplate.html',
                scope: { // 独立作用域
                    ds: "=ngModel",
                    celldbclickFn: "&celldbclick",
                    toolbarLpLbClickFn: "&toolbarlplbclick"
                },
                controllerAs: "$saPlanInfoViewCtrl",
                bindToController: true,
                controller: function() {
                    var self = this;
                    // .ttInfo_detail高度
                    self.ttInfo_detail_height = 800;
                    // ds绑定的数据-路牌扩展数据
                    self.ds_ext_lp_info = {"路牌名字" : {allLb : "关联的班次是否全部烂班(true/false)"}};
                    // ds绑定的数据-线路扩展数据
                    self.ds_ext_xl_info = {"dir0_qdzName" : "上线起点站名字", "dir0_tip_width" : "上行图标宽度",
                        "dir1_qdzName" : "下行起点站名字", "dir1_tip_width" : "下行图标宽度"};
                    // ds绑定的数据-标题扩展数据1
                    self.ds_head_info1 = ["路牌", "驾驶员", "自编号", "车牌号"];
                    // ds绑定的数据-标题扩展数据2
                    self.ds_head_info2 = [];

                    // TODO：后面可能还有其他扩展信息

                },
                /**
                 * compile阶段，angular还没有编译模版，根据需要可以修改模版dom
                 * @param tElem
                 * @param tAttrs
                 * @returns {{pre: Function, post: Function}}
                 */
                compile: function(tElem, tAttrs) {
                    // 获取属性
                    var $attr_name = tAttrs["name"]; // 控件的名字
                    if (!$attr_name) {
                        throw new Error("saPlanInfoView指令 name属性required");
                    }

                    var $attr_celldbclick = tAttrs["celldbclick"]; // 单元格双击事件名
                    var $atrr_toolbarlplbclick = tAttrs["toolbarlplbclick"]; // 工具栏路牌烂班点击事件

                    // 内部controlAs名字
                    var ctrlAs = '$saPlanInfoViewCtrl';

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

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

                            // ------------------- dom事件处理function -----------------//
                            scope[ctrlAs].$$cell_click = function(rowindex, colindex, cell) {
                                console.log("click " + "row=" + rowindex + ",col=" + colindex);
                                if (cell.id) { // 有排班明细id的cell才能操作
                                    cell.sel = !cell.sel; // 是否选中toggle
                                }

                            };
                            scope[ctrlAs].$$cell_dbclick = function(rowindex, colindex, cell) {
                                if (cell.id) { // 有排班明细id的cell才能操作
                                    if ($attr_celldbclick) {
                                        // 注意调用方法
                                        scope[ctrlAs].celldbclickFn()(rowindex, colindex);
                                    }
                                }
                            };
                            // 工具栏单击事件
                            scope[ctrlAs].$$toolbar1_dbclick = function() {
                                if ($atrr_toolbarlplbclick) {
                                    scope[ctrlAs].toolbarLpLbClickFn()();
                                }

                            };

                            // ------------------- 监控function ------------------//
                            // 监控 ds: "=ngModel" 数据
                            scope.$watch(
                                function() {
                                    return scope[ctrlAs].ds;
                                },
                                function(newValue) {
                                    // 创建ds绑定的数据-路牌扩展数据
                                    if (newValue["contents"]) {
                                        angular.forEach(newValue["contents"], function(value) {
                                            var _lpName = value[0]["lpName"];
                                            scope[ctrlAs]["ds_ext_lp_info"][_lpName] = {allLb : false};
                                            var _bcCounts = 0; // 班次总数
                                            var _lbBcCounts = 0; // 烂班班次总数
                                            angular.forEach(value, function(bc) {
                                                if (bc.id) {
                                                    _bcCounts ++;
                                                    if (bc.status == -1) {
                                                        _lbBcCounts ++;
                                                    }
                                                }
                                            });
                                            if (_bcCounts > 0 && _bcCounts == _lbBcCounts) {
                                                scope[ctrlAs]["ds_ext_lp_info"][_lpName].allLb = true;
                                            }
                                        });
                                    }

                                    // 创建ds绑定数据-线路扩展数据
                                    scope[ctrlAs]["ds_ext_xl_info"] = {};
                                    scope[ctrlAs]["ds_ext_xl_info"].dir0_qdzName = "";
                                    scope[ctrlAs]["ds_ext_xl_info"].dir1_qdzName = "";
                                    scope[ctrlAs]["ds_ext_xl_info"].dir0_tip_width = 50;
                                    scope[ctrlAs]["ds_ext_xl_info"].dir1_tip_width = 50;
                                    if (newValue["contents"]) {
                                        angular.forEach(newValue["contents"], function(value) {
                                            if (scope[ctrlAs]["ds_ext_xl_info"].dir0_qdzName
                                                && scope[ctrlAs]["ds_ext_xl_info"].dir1_qdzName) {
                                                return;
                                            }
                                            angular.forEach(value, function (bc) {
                                                if (bc.id && bc.bcType == 'normal') {
                                                    if (bc.xlDir == '0' && bc.qdzName && !scope[ctrlAs]["ds_ext_xl_info"].dir0_qdzName) {
                                                        scope[ctrlAs]["ds_ext_xl_info"].dir0_qdzName = bc.qdzName;
                                                        scope[ctrlAs]["ds_ext_xl_info"].dir0_tip_width += bc.qdzName.length * 15;
                                                    } else if (bc.xlDir == '1' && bc.qdzName && !scope[ctrlAs]["ds_ext_xl_info"].dir1_qdzName) {
                                                        scope[ctrlAs]["ds_ext_xl_info"].dir1_qdzName = bc.qdzName;
                                                        scope[ctrlAs]["ds_ext_xl_info"].dir1_tip_width += bc.qdzName.length * 15;
                                                    }
                                                }

                                            })
                                        });
                                    }

                                    // 计算 .ttInfo_detail高度
                                    scope[ctrlAs]["ttInfo_detail_height"] = 0;
                                    var toolbar_height = 31; // 工具栏高度（参见template css）
                                    var tt_table_head_height = 36; // 表格标题高度（参见template css）
                                    var table_info_height = 30; // 表格行高度（参见template css）
                                    var table_extra_height = 30; // 表格修正高度
                                    if (newValue["contents"]) {
                                        scope[ctrlAs]["ttInfo_detail_height"] =
                                            toolbar_height +
                                            tt_table_head_height +
                                            table_info_height * newValue["contents"].length +
                                            table_extra_height;
                                    }

                                    // 创建ds绑定的数据-标题扩展数据2
                                    scope[ctrlAs]["ds_head_info2"] = [];
                                    angular.forEach(newValue["header"], function(head) {
                                        if (head != '路牌' && head != '驾驶员' && head != '自编号' && head != '车牌号') {
                                            scope[ctrlAs]["ds_head_info2"].push(head);
                                        }
                                    });
                                    // 2个班次一组 [上行group_no，下行group_no]，从1开始
                                    var group_num = 1;
                                    var group_num_array = [1, 1];
                                    for (var i = 0; i < scope[ctrlAs]["ds_head_info2"].length; i++) {
                                        var head = scope[ctrlAs]["ds_head_info2"][i];
                                        if (head == scope[ctrlAs]["ds_ext_xl_info"].dir0_qdzName) {
                                            scope[ctrlAs]["ds_head_info2"][i] = head.substr(0, 1) + group_num_array[0];
                                        } else {
                                            scope[ctrlAs]["ds_head_info2"][i] = head.substr(0, 1) + group_num_array[1];
                                            group_num ++ ;
                                            group_num_array = [group_num, group_num];
                                        }

                                        // TODO：如果是环线的话，目前group_num都是1，后面如果有变化再修正
                                    }

                                    // TODO：

                                },
                                true
                            );

                        }

                    };

                }
            };
        }
    ]
);