basicDataModule
    .controller('EnterpriseAccountManageController', ['$scope', '$location', '$log', 'SweetAlert', 'keywordmapService', 'uiGridConstants', '$translate', 'enterpriseAccountService', 'Upload', 'apiInterceptor', 'templateFormulaService', 'stdAccountService', '$interval', '$timeout', '$q', 'region',
        function ($scope, $location, $log, SweetAlert, keywordmapService, uiGridConstants, $translate, enterpriseAccountService, Upload, apiInterceptor, templateFormulaService, stdAccountService, $interval, $timeout, $q, region) {

            'use strict';

            // default enterprise account
            var defaultEnterpriceAccount = {
                id: '0',
                name: '',
                fullName: '',
                code: '',
                parentCode: '',
                acctLevel: 0,
                selectValue: ' '
            };

            // 添加关联机构ID
            var addEnterpriceAccountSetRelevantOrg = 'addEnterpriceAccountSetRelevantOrg';

            // 编辑关联机构
            var updateEnterpriceAccountSetRelevantOrg = 'updateEnterpriceAccountSetRelevantOrg';

            var expiredDateTo = $translate.instant('ExpiredDateTo');
            // upload file url
            var uploadUrl = apiInterceptor.webApiHostUrl + '/enterpriseAccountManage/Upload';
            var resumable = true;

            // is active map
            var isActiveMap = {
                false: 'Disable',
                true: 'Enable'
            };

            // is actived map
            var isActivedMap = {
                false: 'Disabled',
                true: 'Enabled'
            };

            var parseObj = function (obj) {
                return JSON.parse(obj);
            }

            $scope.enterpriseAccountSetSelect = function (obj) {

                if (obj) {
                    // set
                    $scope.enterpriseAccountSetSelectJson = obj.id;
                } else {

                    // get
                    if ($scope.enterpriseAccountSetSelectJson) {

                        var obj = _.find($scope.enterpriseAccountList, function (num) {
                            return num.id === $scope.enterpriseAccountSetSelectJson;
                        });

                        return obj;
                    } else {
                        return null;
                    }
                }
            };

            $scope.selectStandardAccount = function (obj) {
                if (obj) {
                    // set
                    $scope.selectStandardAccountID = obj.id;
                } else {

                    // get
                    if ($scope.selectStandardAccountID) {
                        return _.find($scope.enterpriceAccountList, function (num) {
                            return num.id === $scope.selectStandardAccountID
                        });

                    } else {
                        return null;
                    }
                }
            };

            // last edit code
            $scope.lastCode = null;

            // all enterprise account list
            var allEnterpriceAccountList = [];

            var errorTypeList = [
                constant.enterpriceAccount.codeEmpty,
                constant.enterpriceAccount.codeMaxLength,
                constant.enterpriceAccount.enterpriseAccountNameEmpty,
                constant.enterpriceAccount.nameMaxLength,
                constant.enterpriceAccount.directionFormatError,
                constant.enterpriceAccount.acctPropFormatError,
                constant.enterpriceAccount.noParentCode
            ];

            // load enterprice account list
            var loadEnterpriceAccountList = function () {
                enterpriseAccountService.getListByEnterpriseAccountSetID($scope.enterpriseAccountSetSelectID).success(function (result) {

                    var data = result.enterpriseAccountList;

                    data.forEach(function (row) {

                        row.selectValue = row.code + ' ' + row.fullName;
                        row.isActiveStr = $translate.instant(isActivedMap[row.isActive]);

                        if (row.parentCode) {
                            row.parent = row.parentCode + ' ' + row.parentName;
                        } else {
                            row.parent = '';
                        }

                        row.directionStr = $scope.directionMap[row.direction + ''];

                        if (row.acctProp <= 6 && row.acctProp >= 0) {
                            row.acctPropStr = $scope.acctPropArray[row.acctProp];
                        } else {
                            //row.acctPropStr = row.acctProp + '';
                            row.acctPropStr = '';
                        }

                    });

                    var list = data.concat();
                    list = _.sortBy(list, 'code');

                    if (list && list.length > 0) {
                        list.splice(0, 0, defaultEnterpriceAccount);
                    } else {
                        list = [];
                        list.push(defaultEnterpriceAccount);
                    }

                    $scope.enterpriceAccountList = list;

                    allEnterpriceAccountList = copyArray(list);
                    $scope.gridOptions.data = data;
                    $scope.gridOptions.noData = data.length === 0;
                    setDefaultTheme();
                    if ($scope.lastCode) {

                        var entity = _.find(list, function (num) {
                            return num.code === $scope.lastCode;
                        });
                        if (entity) {
                            $scope.singleSelected = {};
                            $scope.singleClick(entity);
                            scrollSetting();
                        }
                    }

                    loadImportErrorInfoList(result.validateInfoList);
                });
            };

            var loadImportErrorInfoList = function (data) {
                setErrorWrapCssDefault();

                if (data && data.length > 0) {
                    var i = 1;
                    data.forEach(function (row) {
                        row.detail = row.inValidateCodeList.join(constant.comma);
                        if (row.type === 'EnterpriceAccountRepeat') {
                            row.isRepeatError = true;
                        } else {
                            row.isRepeatError = false;
                        }

                        row.type = $translate.instant(row.type);
                        row.index = i;
                        i++;
                    });
                }

                $scope.importErrorInfoList = data;

                $scope.importErrorTips = $translate.instant('ImportErrorTips').format($scope.importErrorInfoList.length);
                if ($scope.importErrorInfoList && $scope.importErrorInfoList.length > 0) {
                    $scope.ImportErrorTag = true;

                    $timeout(function () {
                        $scope.toggleErrorTab();

                    }, 100);

                } else {
                    $scope.ImportErrorTag = false;
                }
                $scope.ImportErrorTab = false;

                $scope.errorGridOptions.data = data;

            };

            // copy array
            var copyArray = function (data) {
                var copyRet = [];
                if (data && data.length > 0) {
                    data.forEach(function (row) {
                        copyRet.push(row);
                    });
                }

                return copyRet;
            };

            // load enterpriseAccountSetList
            var loadEnterpriseAccountSetList = function () {


                enterpriseAccountService.getEnterpriseAccountSetList().success(function (data) {

                    if (data && data.length > 0) {
                        // data = _.sortBy(data, 'name');
                        data = sortByEnterpriseName(data);
                    }

                    $scope.enterpriseAccountSetList = data;

                    if (data && data.length > 0) {
                        $scope.hasEnterpriseAccountSet = true;

                        // 默认设置为上次编辑或者添加的账套
                        // 如果没有就设置为第一条数据
                        var setDefault = false;
                        if ($scope.editModel && $scope.editModel.name && $scope.editModel.name.length > 0) {
                            var first = _.find(data, function (num) {
                                return num.name === $scope.editModel.name
                            });

                            if (first && first.name) {
                                $scope.enterpriseAccountSetSelectID = first.id;
                                setDefault = true;
                            }
                        }

                        if (!setDefault) {
                            $scope.enterpriseAccountSetSelectID = data[0].id;
                        }

                        $scope.changeEnterpriseAccountSet();

                        //loadEnterpriceAccountList();
                    } else {
                        $scope.hasEnterpriseAccountSet = false;
                    }
                });
            };

            // 添加关联机构列表
            $scope.newRelevantOrgList = function () {

                $scope.editModel = {};
                $scope.isAdd = true;
                var set = _.find($scope.enterpriseAccountSetList, function (num) {
                    return num.id === $scope.enterpriseAccountSetSelectID
                });
                $scope.editModel.id = $scope.enterpriseAccountSetSelectID;

                $scope.editModel.name = set.name;
                $scope.editModel.enterpriseAccountSetOrgList = [];

                $scope.addEnterpriseAccountSetOrg();

                $('#' + addEnterpriceAccountSetRelevantOrg).modal('show');
            };


            $scope.changeEnterpriseAccountSet = function () {
                if (!$scope.enterpriseAccountSetSelectID) {
                    return;
                }

                $scope.ImportErrorTag = false;
                $scope.ImportErrorTab = false;
                loadEnterpriceAccountList();

                loadEnterpriseAccountSet();
            };

            var jumpToAccount = function () {
                // TODO
                if($scope.jumpingEnterpriseAccountSetID){
                    $scope.enterpriseAccountSetSelectID = $scope.jumpingEnterpriseAccountSetID;
                    $scope.changeEnterpriseAccountSet();
                }
            };


            var loadEnterpriseAccountSet = function () {
                enterpriseAccountService.getEnterpriseAccountSet($scope.enterpriseAccountSetSelectID).success(function (data) {

                    if (data && data.enterpriseAccountSetOrgList && data.enterpriseAccountSetOrgList.length > 0) {

                        data.enterpriseAccountSetOrgList.forEach(function (row) {
                            // {{row.entity.effectiveDateStr}}{{"ExpiredDateTo"|translate}}{{row.entity.expiredDateStr}}

                            if (!row.effectiveDateStr && !row.expiredDateStr) {

                            } else {
                                row.effectiveSection = row.effectiveDateStr + expiredDateTo + row.expiredDateStr;

                                if (!row.effectiveDateStr && row.expiredDateStr) {
                                    row.isRight = true;
                                }
                            }

                        });

                    }

                    $scope.orgGridOptions.data = data.enterpriseAccountSetOrgList;
                });
            };

            var load = function () {

                if ($scope.singleSelected && $scope.singleSelected.id) {
                    // 选中
                    enterpriseAccountService.get($scope.singleSelected.id).success(function (data) {
                        $scope.editModel = data;

                        // $scope.enterpriceAccountList = _.filter(allEnterpriceAccountList, function(num) {
                        //  return num.code !== data.code
                        // });

                        $scope.enterpriceAccountList = getParentList(allEnterpriceAccountList, data.code);
                        // $scope.selectStandardAccount(_.find($scope.enterpriceAccountList, function(num) {
                        //     return num.code === data.parentCode
                        // }));

                        // if (!$scope.selectStandardAccount()) {
                        //     $scope.selectStandardAccount(defaultEnterpriceAccount);
                        // }

                        $scope.selectDirection = _.find($scope.directionList, function (num) {
                            return num.id === data.direction
                        });
                        $scope.selectAcctProp = _.find($scope.acctPropList, function (num) {
                            return num.id === data.acctProp
                        });
                        $scope.isAdd = false;
                    });
                    resetErrorStatus();
                    $('#addEnterpriceAccountPop').modal('show');
                } else {
                    $log.debug('please select one keywordMap...');
                    SweetAlert.warning($translate.instant('PleaseChooseEnterpriseAccount'));
                    return;
                }
            };

            var getParentList = function (allEnterpriceAccountList, code) {

                var currentSubList = getSubEnterpriseAccountList(allEnterpriceAccountList, code);

                var notCurrentNodeList = _.filter(allEnterpriceAccountList, function (num) {
                    return num.code !== code;
                });


                var notCurrentAndSubNodeList = notCurrentNodeList;
                if (notCurrentNodeList && notCurrentNodeList.length > 0 && currentSubList && currentSubList.length > 0) {
                    notCurrentAndSubNodeList = _.filter(notCurrentNodeList, function (num) {
                        var inSubNode = _.find(currentSubList, function (num2) {
                            return num2.code === num.code;
                        });

                        if (inSubNode) {
                            return false;
                        } else {
                            return true;
                        }
                    });
                }

                return notCurrentAndSubNodeList;
            };

            var getSubEnterpriseAccountList = function (allEnterpriceAccountList, code) {
                var list = _.filter(allEnterpriceAccountList, function (num) {
                    return num.parentCode === code;
                });

                if (list && list.length > 0) {
                    list.forEach(function (row) {
                        var tempList = getSubEnterpriseAccountList(allEnterpriceAccountList, row.code);

                        if (tempList && tempList.length > 0) {
                            list = _.union(list, tempList);
                        }
                    });
                }

                return list;
            };

            $scope.codeChange = function (code) {
                $scope.editModel.checkHasParent = true;
                if (code) {

                    var result = null;
                    for (var i = code.length - 1; i >= 0; i--) {
                        result = _.find($scope.enterpriceAccountList, function (num) {
                            return num.code === code.substr(0, i);
                        });

                        if (result) {
                            break;
                        }
                    }

                    if (result) {
                        $scope.editModel.parentCode = result.code;
                        $scope.editModel.parentFullName = result.fullName;
                        $scope.editModel.parentAcctLevel = result.acctLevel;
                    }
                }

            };

            var save = function () {
                if (!$scope.editModel.checkHasParent) {
                    // 直接点的保存,没有上级科目
                    $scope.codeChange($scope.editModel.code);
                }

                if (!($('#addEnterpriceAccountForm').valid())) {
                    return;
                }

                $scope.editModel.isActive = true;
                $scope.editModel.ruleType = 2;
                $scope.editModel.enterpriseAccountSetID = $scope.enterpriseAccountSetSelectID;

                if ($scope.editModel.parentCode && $scope.editModel.parentCode.length > 0) {
                    $scope.editModel.fullName = $scope.editModel.parentFullName + '-' + $scope.editModel.name;
                    $scope.editModel.acctLevel = $scope.editModel.parentAcctLevel + 1;
                } else {
                    $scope.editModel.acctLevel = 1;
                    $scope.editModel.fullName = $scope.editModel.name;
                    $scope.editModel.parentCode = null;
                }

                if ($scope.selectDirection && $scope.selectDirection.id) {
                    $scope.editModel.direction = $scope.selectDirection.id;
                }

                if ($scope.selectAcctProp && $scope.selectAcctProp.id) {
                    $scope.editModel.acctProp = $scope.selectAcctProp.id;
                }

                if ($scope.isAdd) {
                    enterpriseAccountService.add($scope.editModel).success(function (data) {
                        if (!data.result) {
                            var errorList = [];
                            var template = $translate.instant(data.resultMsg);
                            SweetAlert.warning(template);
                            return;
                        }
                        ;

                        $scope.lastCode = $scope.editModel.code;

                        SweetAlert.success($translate.instant('SaveSuccess'));
                        $('#addEnterpriceAccountPop').modal('hide');
                        loadEnterpriceAccountList();
                    });
                } else {
                    enterpriseAccountService.update($scope.editModel).success(function (data) {
                        if (!data.result) {
                            var errorList = [];
                            var template = $translate.instant(data.resultMsg);

                            SweetAlert.warning(template);
                            return;
                        }
                        ;

                        $scope.lastCode = $scope.editModel.code;
                        SweetAlert.success($translate.instant('SaveSuccess'));

                        $('#addEnterpriceAccountPop').modal('hide');
                        loadEnterpriceAccountList();
                    });
                }
            };

            var search = function () {
                $scope.dataGridApi.grid.refresh();
            };

            // 新增
            var newModel = function () {
                $scope.editModel = {};

                $scope.isAdd = true;
                $scope.enterpriceAccountList = allEnterpriceAccountList;
                $scope.selectStandardAccount(defaultEnterpriceAccount);
                $scope.selectDirection = null;
                $scope.selectAcctProp = _.find($scope.acctPropList, function (num) {
                    return num.id === -1
                });
                $scope.file = null;
                resetErrorStatus();
                $('#addEnterpriceAccountPop').modal('show');
            };

            var resetErrorStatus = function () {
                var currentForm = $('#addEnterpriceAccountForm');
                $('#addEnterpriceAccountForm .has-error > label').remove();

                $('#addEnterpriceAccountForm').find('.has-error').removeClass('has-error');
                validator.resetForm();
            };

            var resources = {
                codeRequired: $translate.instant('EnterpriceAccountCodeRequired'),
                nameRequired: $translate.instant('EnterpriceAccountNameRequired'),
                selectDirectionRequired: $translate.instant('StandardAccountRequired'),
                //selectAcctPropRequired: $translate.instant('StandardAccountAccountTypesRequired'),
                setnameRequired: $translate.instant('EnterpriceAccountSetNameRequired'),
                setcodeRequired: $translate.instant('EnterpriseAccountSetCodeRequired'),
                setfileRequired: $translate.instant('EnterpriceAccountSetFileRequired'),
                enterpriseAccountSetNameRepeat: $translate.instant('EnterpriseAccountSetNameRepeat'),
                enterpriseAccountSetCodeRepeat: $translate.instant('EnterpriseAccountSetCodeRepeat'),
                organizationRequired: $translate.instant('SelectOrganizationRequired'),
                effectiveDateRequired: $translate.instant('EffectiveDateRequired'),
                expiredDateRequired: $translate.instant('ExpiredDateRequired')
            };


            var validator = $("#addEnterpriceAccountForm").validate({
                errorClass: "has-error",
                rules: {
                    code: {
                        required: true
                    },
                    name: {
                        required: true
                    },
                    selectDirection: {
                        required: true
                    },
                    //selectAcctProp: {
                    //    required: true
                    //},
                    organization: {
                        required: true
                    },
                    effectiveDate: {
                        required: true
                    },
                    expiredDate: {
                        required: true
                    }
                },
                messages: {
                    code: {
                        required: resources.codeRequired
                    },
                    name: {
                        required: resources.nameRequired
                    },
                    selectDirection: {
                        required: resources.selectDirectionRequired
                    },
                    //selectAcctProp: {
                    //    required: resources.selectAcctPropRequired
                    //},
                    organization: {
                        required: resources.organizationRequired
                    },
                    effectiveDate: {
                        required: resources.effectiveDateRequired
                    },
                    expiredDate: {
                        required: resources.expiredDateRequired
                    }

                },
                errorPlacement: function (error, element) {
                    setErrorStyle(error, element);
                }
            });

            var setErrorStyle = function (error, element) {
                if (element.hasClass('has-error')) {
                    element.parent().addClass('has-error');
                    error.insertAfter(element);
                    error.addClass('label');
                }
            };

            var validatorset = $("#addEnterpriceAccountSetForm").validate({
                errorClass: "has-error",
                rules: {
                    name: {
                        required: true,
                        remote: {
                            type: "get",
                            url: apiInterceptor.webApiHostUrl + "/enterpriseAccountManage/enterpriseAccountSetNameValidate",
                            data: {
                                id: function () {
                                    return $("#enterpriseAccountSetID").val();
                                },
                                name: function () {
                                    return $("#enterpriseAccountSetName").val();
                                }
                            },
                            dataType: "json",
                            dataFilter: function (data, type) {

                                var ret = JSON.parse(data);
                                if (ret && ret.result)
                                    return true;
                                else
                                    return false;
                            }
                        }
                    },
                    code: {
                        required: true,
                        remote: {
                            type: "get",
                            url: apiInterceptor.webApiHostUrl + "/enterpriseAccountManage/enterpriseAccountSetCodeValidate",
                            data: {
                                id: function () {
                                    return $("#enterpriseAccountSetID").val();
                                },
                                code: function () {
                                    return $("#enterpriseAccountSetCode").val();
                                }
                            },
                            dataType: "json",
                            dataFilter: function (data, type) {

                                var ret = JSON.parse(data);
                                if (ret && ret.result)
                                    return true;
                                else
                                    return false;
                            }
                        }
                    },
                    fileName: {
                        // 把这条注释条, ng-required生效
                        // required: true
                    },
                    organization: {
                        // required: true
                    },
                    effectiveDate: {
                        // required: true
                    },
                    expiredDate: {
                        // required: true
                    }

                },
                messages: {
                    name: {
                        required: resources.setnameRequired,
                        remote: resources.enterpriseAccountSetNameRepeat
                    },
                    code: {
                        required: resources.setcodeRequired,
                        remote: resources.enterpriseAccountSetCodeRepeat
                    },
                    fileName: {
                        required: resources.setfileRequired
                    },
                    organization: {
                        required: resources.organizationRequired
                    },
                    effectiveDate: {
                        required: resources.effectiveDateRequired
                    },
                    expiredDate: {
                        required: resources.expiredDateRequired
                    }

                },
                errorPlacement: function (error, element) {
                    setErrorStyle(error, element);
                }
            });

            var resetErrorStatusSet = function () {
                var currentForm = $('#addEnterpriceAccountSetForm');
                $('#addEnterpriceAccountSetForm .has-error > label').remove();
                currentForm.find('.has-error').removeClass('has-error');
                validatorset.resetForm();
            };

            var modifyIsActive = function () {

                if ($scope.singleSelected && $scope.singleSelected.id) {

                    SweetAlert.swal({
                            title: $translate.instant('Confirm') + $scope.isActiveBtStr + '?',
                            text: $translate.instant('ComfirmEnterpriceAccountIsActive').formatObj({
                                isActiveStr: $scope.isActiveBtStr,
                                code: $scope.singleSelected.code,
                                fullName: $scope.singleSelected.fullName
                            }),
                            type: "warning",
                            showCancelButton: true,
                            confirmButtonColor: "#DD6B55",
                            confirmButtonText: $translate.instant('Confirm'),
                            cancelButtonText: $translate.instant('Cancel'),
                            closeOnConfirm: false,
                            closeOnCancel: true
                        },
                        function (isConfirm) {
                            if (isConfirm) {
                                // 选中
                                var model = $scope.singleSelected;
                                model.isActive = !model.isActive;
                                enterpriseAccountService.isactive(model).success(function (data) {

                                    // SweetAlert.info('info', 'log success');
                                    if (!data.result) {
                                        model.isActive = !model.isActive;
                                        //SweetAlert.swal($translate.instant(data.resultMsg));
                                        SweetAlert.warning($translate.instant(data.resultMsg));
                                        return;
                                    } else {

                                        SweetAlert.success($translate.instant('SaveSuccess'));
                                        //SweetAlert.swal($translate.instant('Confirm') + $scope.isActiveBtStr, $translate.instant('Confirm') + $scope.isActiveBtStr + $translate.instant("SaveSuccess"), "success");
                                        loadEnterpriceAccountList();

                                        var newModel = _.find($scope.gridOptions.data, function (num) {
                                            return num.id === model.id
                                        });
                                        newModel.repeatSingleClick = true;
                                        $scope.singleClick(newModel);
                                    }
                                });
                            }
                        });
                } else {
                    $log.debug('please select one keywordMap...');
                }
            };

            $scope.parentChange = function () {

                var tempselectStandardAccount = $scope.selectStandardAccount();
                if (tempselectStandardAccount && tempselectStandardAccount.code && tempselectStandardAccount.code.length > 0) {
                    $scope.selectDirection = _.find($scope.directionList, function (num) {
                        return num.id === tempselectStandardAccount.direction
                    });
                    $scope.selectAcctProp = _.find($scope.acctPropList, function (num) {
                        return num.id === tempselectStandardAccount.acctProp
                    });
                } else {
                    $scope.selectDirection = null;
                    $scope.selectAcctProp = null;
                }
            };

            $scope.newAccountSetModal = function () {
                $scope.editModel = {};
                $scope.editModel.enterpriseAccountSetOrgList = [];
                $scope.editModel.RegionNames = '';
                $scope.isAdd = true;
                resetErrorStatusSet();
                $scope.file = null;
                $('#addEnterpriceAccountSetPop').modal('show');
            };

            $scope.saveEnterpriseAccountSet = function () {

                resetErrorStatusSet();
                if (!($('#addEnterpriceAccountSetForm').valid())) {
                    return;
                }

                if ($scope.isAdd && !$scope.file) {
                    SweetAlert.warning($translate.instant(resources.setfileRequired));
                    return;
                }

                enterpriseAccountSetOrgValidate();
            };

            // 验证机构唯一性
            var enterpriseAccountSetOrgValidate = function () {
                var model = {
                    id: $scope.editModel.id,
                    enterpriseAccountSetOrgList: []
                };

                // if (!getEnterpriseAccountSetOrgListUI()) {
                //     return;
                // }

                // model.enterpriseAccountSetOrgList = $scope.editModel.saveOrgList;

                enterpriseAccountService.enterpriseAccountSetOrgValidate(model).success(function (data) {
                    if (data && data.result) {
                        // 验证成功
                        saveEditEnterpriseAccountSet();
                    } else {
                        if (data.data && data.data.length > 0) {
                            var orgNameList = [];
                            var i = 1;
                            data.data.forEach(function (row) {
                                orgNameList.push(i + '.' + $translate.instant('OrganizationName') + ':' + row.organizationName);
                                i++;
                            });

                            orgNameList = getLimitLogs(orgNameList);

                            var str = orgNameList.join('<br/>');

                            str = "<div class='text-left'>" + str + '</div>';

                            SweetAlert.swal({
                                title: $translate.instant(data.resultMsg),
                                text: str,
                                type: "warning",
                                showCancelButton: false,
                                confirmButtonColor: "#DD6B55",
                                confirmButtonText: $translate.instant('Confirm'),
                                cancelButtonText: $translate.instant('Cancel'),
                                closeOnConfirm: false,
                                closeOnCancel: false,
                                html: true
                            });

                        }
                    }

                });
            };

            var saveEditEnterpriseAccountSet = function () {
                resetErrorStatus();
                if (!($('#addEnterpriceAccountSetForm').valid())) {
                    return;
                }

                if ($scope.isAdd) {
                    $scope.isImportAppend = false;
                    importData();
                } else {

                    // 有文件的修改
                    if ($scope.file) {

                        SweetAlert.swal({
                                title: $translate.instant('ComfirmImportData'),
                                text: $translate.instant('EnterpriseAccountSetOverLayImportTips'),
                                type: "warning",
                                showCancelButton: true,
                                confirmButtonColor: "#DD6B55",
                                confirmButtonText: $translate.instant('Confirm'),
                                cancelButtonText: $translate.instant('Cancel'),
                                closeOnConfirm: false,
                                closeOnCancel: true
                            },
                            function (isConfirm) {
                                if (isConfirm) {
                                    // 选中
                                    importData();
                                }
                            });

                    } else {
                        // 没有文件修改
                        var model = {
                            id: $scope.enterpriseAccountSetSelectID,
                            name: $scope.editModel.name,
                            code: $scope.editModel.code
                            // enterpriseAccountSetOrgList: []
                        };

                        // if (!getEnterpriseAccountSetOrgListUI()) {
                        //     return;
                        // }

                        // model.enterpriseAccountSetOrgList = $scope.editModel.saveOrgList;

                        enterpriseAccountService.updateEnterpriseAccountSet(model).success(function (data) {
                            if (data && data.result) {
                                $('#addEnterpriceAccountSetPop').modal('hide');
                                SweetAlert.success($translate.instant('SaveSuccess'));
                                loadEnterpriseAccountSetList();
                            } else {
                                swal($translate.instant('SaveFail'), $translate.instant(data.resultMsg), 'warning');
                            }
                        });
                    }
                }
            };

            var importData = function () {
                if (!$scope.file || !$scope.file.name) {

                    SweetAlert.info($translate.instant('SelectCustomerFileRequired'));
                    return;
                }

                var deferred = $q.defer();

                var tempFileName = PWC.newGuid() + '.dat';
                var token = $('input[name="__RequestVerificationToken"]').val();

                // if (!getEnterpriseAccountSetOrgListUI()) {
                //     return;
                // }

                // var orgList = $scope.editModel.saveOrgList;
                // var json = JSON.stringify(orgList);

                var enterpriseAccountSetID = $scope.isAdd ? '' : $scope.enterpriseAccountSetSelectID;

                $('#busy-indicator-container').show();

                // updateProgressToZero();
                Upload.upload({
                    url: uploadUrl,
                    data: {
                        cancel: false,
                        filename: $scope.file.name,
                        tempFileName: tempFileName,
                        Remark: $scope.remark,
                        name: $scope.editModel.name,
                        code: $scope.editModel.code,
                        // selectedOrgList: json,
                        enterpriseAccountSetID: enterpriseAccountSetID,
                        isImportAppend: $scope.isImportAppend,
                    },
                    file: $scope.file,
                    resumeChunkSize: resumable ? $scope.chunkSize : null,
                    headers: {
                        'Access-Control-Allow-Origin': '*',
                        Authorization: apiInterceptor.tokenType + ' ' + apiInterceptor.apiToken(),
                        __RequestVerificationToken: token,
                        withCredentials: true
                    },
                    __RequestVerificationToken: token,
                    withCredentials: true
                }).then(function (resp) {
                    var ret = resp.data;
                    $('#busy-indicator-container').hide();
                    deferred.resolve();
                    if (ret.result) {

                        $scope.errList = [];
                        $scope.ImportErrorTag = false;
                        // 全部导入成功
                        $('#addEnterpriceAccountSetPop').modal('hide');
                        $('#importEnterpriceAccountSetPop').modal('hide');
                        if ($scope.isAdd) {
                            SweetAlert.success($translate.instant('AddSuccess'));
                        } else {
                            SweetAlert.success($translate.instant('ImportSuccess'));
                        }

                        loadEnterpriseAccountSetList();
                    } else {

                        if (ret.resultMsg && ret.resultMsg.length > 0) {
                            SweetAlert.warning($translate.instant(ret.resultMsg));
                            //SweetAlert.swal($translate.instant(ret.resultMsg));
                            $scope.errList = [];
                            $scope.ImportErrorTag = false;
                        } else {
                            // 提示没有导入成功的数据
                            var codeNameList = [];

                            var errorInfo = $translate.instant('ImportErrorTips').format(ret.data.length);
                            $scope.errList = ret.data;
                            $scope.ImportErrorTag = true;
                            loadEnterpriseAccountSetList();

                            SweetAlert.swal({
                                title: $translate.instant('EnterpriceAccountManage'),
                                text: errorInfo,
                                type: "info",
                                showCancelButton: false,
                                closeOnConfirm: false,
                                closeOnCancel: true,
                                html: true
                            });

                        }
                    }

                }, function (resp) {
                    deferred.resolve();

                    if (resp.statusText === 'HttpRequestValidationException') {
                        SweetAlert.warning($translate.instant('HttpRequestValidationException'));
                    } else {
                        SweetAlert.warning('SaveFail');
                    }

                    console.log('Error status: ' + resp.status);
                }, function (evt) {
                    deferred.resolve();
                    var progressPercentage = parseInt(100.0 * evt.loaded / evt.total);
                    $log.debug('progress: ' + progressPercentage + '% ' + evt.config.data.file.name);
                });
            };

            $scope.overlayUpload = function () {
                $scope.isImportAppend = false;
                if ($scope.file) {

                    SweetAlert.swal({
                            title: $translate.instant('ComfirmImportData'),
                            text: $translate.instant('EnterpriseAccountSetOverLayImportTips'),
                            type: "warning",
                            showCancelButton: true,
                            confirmButtonColor: "#DD6B55",
                            confirmButtonText: $translate.instant('Confirm'),
                            cancelButtonText: $translate.instant('Cancel'),
                            closeOnConfirm: false,
                            closeOnCancel: true
                        },
                        function (isConfirm) {
                            if (isConfirm) {

                                $scope.editModel = {};
                                var set = _.find($scope.enterpriseAccountSetList, function (num) {
                                    return num.id === $scope.enterpriseAccountSetSelectID;
                                });
                                $scope.editModel.name = set.name;

                                $scope.isAdd = false;
                                // 选中
                                importData();
                            }
                        });
                } else {
                    SweetAlert.info($translate.instant('SelectCustomerFileRequired'));
                    return;
                }
            };

            $scope.editEnterpriseAccountSet = function () {
                $scope.editModel = {};
                $scope.isAdd = false;
                resetErrorStatusSet();
                $scope.file = null;
                enterpriseAccountService.getEnterpriseAccountSet($scope.enterpriseAccountSetSelectID).success(function (data) {
                    $scope.editModel = data;
                    $scope.editModel.IsEdit = true;
                    setEditEnterpriseAccountSetOrgList();
                });

                $('#addEnterpriceAccountSetPop').modal('show');
            };

            var scrollSetting = function () {
                var ex = document.getElementById("enterpriseAccountUIGrid");
                if (ex) {
                    ex.scrollTop = ex.scrollHeight;
                }
            };

            var getLimitLogs = function (arr) {

                if (arr.length > constant.errorMaxLine) {
                    $log.debug(JSON.stringify(arr));
                    arr = arr.slice(0, constant.errorMaxLine);
                    arr.push('.....');
                    return arr;
                }

                return arr;
            };


            $scope.toggleErrorTab = function () {
                $scope.ImportErrorTab = !$scope.ImportErrorTab;

                // topIcon and content-resize gapBottom 15px
                if (!$scope.ImportErrorTab) {
                    setErrorWrapCssDefault();
                } else {

                    if (parseInt($('#content-resizer').css('bottom')) < 100) {
                        $('#content-resizer').css('bottom', '100px');
                        $('#topIcon').css({
                            bottom: '90px',
                        });

                        $('.error-wrap').css('height', '100px');
                    }
                }
            };

            var setErrorWrapCssDefault = function () {
                $('#content-resizer').css('bottom', '25px');
                $('#topIcon').css({
                    bottom: '15px',
                });

                $('.error-wrap').css('height', '0px');
            };

            var setDefaultTheme = function () {
                if ($scope.gridOptions.data && $scope.gridOptions.data.length > 0) {
                    $scope.gridOptions.data.forEach(function (row) {
                        row.isHighLight = false;
                    });
                }
            };

            $scope.chooseRelavantRow = function (err) {

                setDefaultTheme();

                var selectedAccount = null;

                var index = 0;

                if (err && err.inValidateCodeList && err.inValidateCodeList.length > 0) {
                    err.inValidateCodeList.forEach(function (row) {

                        var matchList = _.filter($scope.gridOptions.data, function (num) {
                            return num.code === row
                        });

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

                            if (!selectedAccount) {
                                selectedAccount = matchList[0];

                                index = _.findIndex($scope.gridOptions.data, function (num) {
                                    return num.code === row;
                                });
                            }

                            matchList.forEach(function (row2) {
                                row2.isHighLight = true;
                                $log.debug(row2.code);
                            });
                        }

                    });
                }

                if (selectedAccount) {

                    $timeout(function () {
                        $scope.singleSelected = {};
                        $scope.singleClick(selectedAccount);
                        scrollSetting();

                        var gridApi = $scope.dataGridApi;
                        var rowIndex = gridApi.grid.renderContainers.body.visibleRowCache.indexOf(gridApi.grid.rows[index]);
                        gridApi.grid.element[0].getElementsByClassName("ui-grid-viewport")[0].scrollTop = rowIndex * gridApi.grid.options.rowHeight;
                    }, 100);

                }
            };

            $scope.getGridHeight = function () {

                if ($scope.isLoadComplete) {
                    var y = $("#enterprise-account-error-wrap").height();

                    // Enough space
                    if (y > constant.UIGrid.gapHeight) {
                        y = y - constant.UIGrid.gapHeight;
                        return {
                            height: y + "px"
                        };
                    } else {

                        return {
                            height: '0px'
                        };
                    }
                }

                return {};
            }

            $scope.getEnterpriseAccountUIGridHeight = function () {
                if ($scope.isLoadComplete) {
                    var y = $('.import-result').height();
                    if (y > constant.UIGrid.gapHeight) {
                        y = y - constant.UIGrid.gapHeight;
                        return {
                            height: y + "px"
                        };
                    }

                    return {};
                }

                return {};
            };

            $scope.getOrgListUIGridHeight = function () {
                if ($scope.isLoadComplete) {
                    var y = $('.enterprise-account-list-wrap').height();
                    if (y > constant.UIGrid.gapHeight) {
                        // y = y - constant.UIGrid.gapHeight + 4;
                        return {
                            height: y + "px"
                        };
                    }
                }

                return {};
            };

            var clearRepeatData = function (row) {

                SweetAlert.swal({
                        title: $translate.instant('ConfirmOperation'),
                        text: $translate.instant('ClearRepeatItemTips'),
                        type: "warning",
                        showCancelButton: true,
                        confirmButtonColor: "#DD6B55",
                        confirmButtonText: $translate.instant('Confirm'),
                        cancelButtonText: $translate.instant('Cancel'),
                        closeOnConfirm: false,
                        closeOnCancel: true
                    },
                    function (isConfirm) {
                        if (isConfirm) {

                            enterpriseAccountService.clearRepeatEnterpriseAccountList($scope.enterpriseAccountSetSelectID, row.inValidateCodeList).success(function (data) {

                                if (data && data.result) {
                                    SweetAlert.success($translate.instant('SaveSuccess'));
                                }

                                loadEnterpriceAccountList();
                            });
                        }
                    });
            };

            var errorGridOptionsFun = function () {
                $scope.errorGridOptions = {
                    rowHeight: 30,
                    selectionRowHeaderWidth: 30,
                    enableSorting: true,
                    enableColumnMenus: false,
                    enableHorizontalScrollbar: uiGridConstants.scrollbars.NEVER,
                    enableRowSelection: false, // 行选择是否可用,默认为true; 如果想选择任意位置和勾勾,需要设置为false
                    enableRowHeaderSelection: false,
                    enableFullRowSelection: false, //是否点击行任意位置后选中,默认为false
                    enableSelectAll: false, // 选择所有checkbox是否可用,默认为true; 
                    multiSelect: false, // 是否可以选择多个,默认为true;
                    columnDefs: [{
                        field: 'index',
                        name: $translate.instant('SequenceNo'),
                        width: '10%',
                        cellTemplate: '<div class="ui-grid-cell-contents" ng-click="grid.appScope.chooseRelavantRow(row.entity)"><span>{{row.entity.index}}</span></div>'
                    }, {
                        field: 'type',
                        name: $translate.instant('ErrorMesssage'),
                        width: '30%',
                        cellTemplate: '<div class="ui-grid-cell-contents" ng-click="grid.appScope.chooseRelavantRow(row.entity)"><span>{{row.entity.type}}</span></div>'
                    }, {
                        field: 'errorMsg',
                        name: $translate.instant('EnterpriseAccountErrorCodeList'),
                        cellTemplate: '<div class="ui-grid-cell-contents" ng-click="grid.appScope.chooseRelavantRow(row.entity)">' +
                            '<span title="{{row.entity.detail}}">{{row.entity.detail}}</span>' +

                            '</div>',
                        width: '45%',
                    }, {
                        name: $translate.instant('OrganizationStructureOperation'),
                        width: '15%',
                        headerCellClass: 'center',
                        enableFiltering: false,
                        cellTemplate: '<div class="grid-operation">' +
                            '<a ng-show="row.entity.isRepeatError" class="btn btn-in-grid" href="javascript:void(0)" ng-click="grid.appScope.clearRepeatData(row.entity)"> <i class="material-icons">clear</i><span>{{"ClearRepeatItem" | translate }}</span></a>' +

                            '</div>'
                    }],

                    onRegisterApi: function (gridApi) {
                        $scope.errorGridApi = gridApi;

                        $interval(function () {
                            $scope.errorGridApi.core.handleWindowResize();
                        }, 500, 60 * 60 * 8);
                    }
                };
            };


            var setEditEnterpriseAccountSetOrgList = function () {
                if (!$scope.editModel.enterpriseAccountSetOrgList) {
                    $scope.editModel.enterpriseAccountSetOrgList = [];
                }

                var index = 1;
                $scope.editModel.enterpriseAccountSetOrgList.forEach(function (item) {
                    item.fromID = 'from' + index;
                    item.toID = 'to' + index;
                    index++;

                    $timeout(function () {

                        $("#" + item.fromID).datepicker({
                            minViewMode: 1,
                            autoclose: true,
                            language: region,
                            format: "yyyy-mm"
                        });

                        $("#" + item.toID).datepicker({
                            minViewMode: 1,
                            autoclose: true,
                            language: region,
                            format: "yyyy-mm"
                        });

                        $("#" + item.fromID).on('changeDate', function () {

                            if ($("#" + item.fromID).val === '') {

                            } else {
                                $("#" + item.toID).datepicker('setStartDate', $("#" + item.fromID).val());
                            }
                        });


                    }, 100);
                });
            };

            $scope.addEnterpriseAccountSetOrg = function () {

                var index = $scope.editModel.enterpriseAccountSetOrgList.length + 1;
                var item = {
                    organizationName: '',
                    organizationID: '',
                    componentSelectedOrg: null,
                    fromID: 'from' + index,
                    toID: 'to' + index
                };

                $scope.editModel.enterpriseAccountSetOrgList.push(item);

                $timeout(function () {

                    $("#" + item.fromID).datepicker({
                        minViewMode: 1,
                        autoclose: true,
                        language: region,
                        format: "yyyy-mm"
                    });

                    $("#" + item.toID).datepicker({
                        minViewMode: 1,
                        autoclose: true,
                        language: region,
                        format: "yyyy-mm"
                    });

                    $("#" + item.fromID).on('changeDate', function () {

                        if ($("#" + item.fromID).val === '') {

                        } else {
                            $("#" + item.toID).datepicker('setStartDate', $("#" + item.fromID).val());
                        }
                    });


                }, 100);
            };

            $scope.deleteEnterpriseAccountSetOrg = function (x) {
                if (x) {
                    $scope.editModel.enterpriseAccountSetOrgList.splice(jQuery.inArray(x, $scope.editModel.enterpriseAccountSetOrgList), 1);
                }
                ;
            };

            var getEnterpriseAccountSetOrgListUI = function () {

                var enterpriseAccountSetOrgList = [];
                var isError = false;
                if ($scope.editModel.enterpriseAccountSetOrgList && $scope.editModel.enterpriseAccountSetOrgList.length > 0) {
                    for (var i = 0; i <= $scope.editModel.enterpriseAccountSetOrgList.length - 1; i++) {
                        var row = $scope.editModel.enterpriseAccountSetOrgList[i];
                        var item = {
                            OrganizationID: row.organizationID,
                            EffectiveDateStr: row.effectiveDateStr,
                            ExpiredDateStr: row.expiredDateStr,
                            EnterpriseAccountSetID: $scope.editModel.id
                        };

                        if (!row.organizationID) {
                            SweetAlert.warning(resources.organizationRequired);
                            return false;
                        }

                        if (!row.effectiveDateStr) {
                            // row.effectiveDateStr = constant.date.minDate;
                            //SweetAlert.warning(resources.effectiveDateRequired);
                            // return false;
                        }

                        if (!row.expiredDateStr) {
                            //row.expiredDateStr = constant.date.maxDate;
                            // SweetAlert.warning(resources.expiredDateRequired);
                            // return false;
                        }

                        if (row.effectiveDateStr && row.expiredDateStr && !validateDate(row.effectiveDateStr, row.expiredDateStr)) {
                            SweetAlert.warning($translate.instant('EffectiveDateAreaProblem'));
                            return false;
                        }

                        enterpriseAccountSetOrgList.push(item);
                    }
                    ;
                }

                $scope.editModel.saveOrgList = enterpriseAccountSetOrgList;
                return true;
            };

            var validateDate = function (from, to) {
                var fromDate = new Date(from + '-01');
                var toDate = new Date(to + '-01');
                toDate.setMonth(toDate.getMonth() + 1);
                toDate.setDate(toDate.getDate() - 1);

                if (fromDate <= toDate) {
                    return true;
                } else {
                    return false;
                }
            };

            var dataType = {
                isPrefixNumber: function (value) {
                    var reg = /^\d+/;
                    if (reg.test(value)) {
                        return true;
                    } else {
                        return false;
                    }
                },
                isPrefixChar: function (value) {
                    var reg = /^[a-zA-Z]+/;
                    if (reg.test(value)) {
                        return true;
                    } else {
                        return false;
                    }
                },
                isPrefixNumberOrChar: function (value) {
                    if (dataType.isPrefixNumber(value)) {
                        return true;
                    }

                    if (dataType.isPrefixChar(value)) {
                        return true;
                    }

                    return false;
                }
            }

            var sortByEnterpriseName = function (data) {
                if (data && data.length > 0) {

                    var charList = [];
                    var nocharList = [];

                    data.forEach(function (row) {
                        if (dataType.isPrefixNumberOrChar(row.name)) {
                            row.nameSort = row.name;

                            if (row.nameSort) {
                                row.nameSort = row.nameSort.toLowerCase();
                            }

                            charList.push(row);

                        } else {
                            nocharList.push(row);
                        }

                    });

                    charList = _.sortBy(charList, 'nameSort');

                    nocharList = nocharList.sort(function compareFunction(param1, param2) {
                        return param1.name.localeCompare(param2.name, 'zh');
                    });

                    var all = _.union(charList, nocharList);
                    return all;
                }

                return data;
            };

            $scope.importAppend = function () {
                $scope.isImportAppend = true;
                $scope.editModel = {};
                var set = _.find($scope.enterpriseAccountSetList, function (num) {
                    return num.id === $scope.enterpriseAccountSetSelectID;
                });

                $scope.editModel.name = set.name;
                $scope.isAdd = false;
                importData();
            };

            $scope.popupImport = function () {
                $scope.file = null;
                $('#importEnterpriceAccountSetPop').modal('show');
            };

            // 机构的UIGrid初始化
            var orgUIGridInit = function () {

                var operateStr = '';

                if ($scope.hasEditPermission) {
                    operateStr = '<div class="project-manage-grid-operation ui-grid-cell-contents">' +
                        '<span ng-click="grid.appScope.editRelevantOrg(row.entity)" class="operate-span" role="button" tabindex="0" aria-hidden="false" style=""><i class="material-icons middle black-color">create</i></span>' +
                        '<span ng-click="grid.appScope.deleteRelevantOrg(row.entity)" class="operate-span" role="button" tabindex="0" aria-hidden="false" style=""><i class="material-icons button-icons middle delete red-color">delete</i></span>' +
                        '</div>';
                } else {
                    operateStr = '<div class="project-manage-grid-operation ui-grid-cell-contents">' +
                        '<span class="operate-span no-permission" role="button" tabindex="0" aria-hidden="false" style=""><i class="material-icons middle black-color">create</i></span>' +
                        '<span class="operate-span no-permission" role="button" tabindex="0" aria-hidden="false" style=""><i class="material-icons button-icons middle delete red-color">delete</i></span>' +
                        '</div>';
                }

                $scope.orgGridOptions = {
                    rowHeight: 40,
                    selectionRowHeaderWidth: constant.UIGrid.selectionRowHeaderWidth,
                    enableFullRowSelection: true,
                    enableRowSelection: true,
                    enableSorting: true,
                    enableFiltering: false,
                    enableColumnMenus: false,
                    enableRowHeaderSelection: false,
                    multiSelect: false,
                    enableHorizontalScrollbar: uiGridConstants.scrollbars.NEVER,
                    columnDefs: [{
                        field: 'organizationName',
                        name: $translate.instant('FieldorgName'),
                        width: '30%',
                        headerCellClass: 'right',
                        enableFiltering: false,

                        cellTemplate: '<div class="ui-grid-cell-contents right"><a title="{{row.entity.organizationName}}" href="#/organization/{{row.entity.organizationID}}">{{row.entity.organizationName}}<a></div>'
                    }, {
                        field: 'EffectiveDateStr',
                        name: $translate.instant('EffectiveDateStr'),
                        width: '40%',
                        headerCellClass: '',
                        cellTemplate: '<div class="ui-grid-cell-contents" ng-class="{\'padding-right45\':row.entity.isRight}"><span title="{{row.entity.effectiveSection}}">{{row.entity.effectiveSection}}<span></div>'
                    }, {
                        name: $translate.instant('Operation'),
                        width: '30%',
                        headerCellClass: 'center',
                        enableFiltering: false,
                        cellTemplate: operateStr
                    }],
                    onRegisterApi: function (gridApi) {
                        $scope.orgGridApi = gridApi;
                        $interval(function () {
                            $scope.orgGridApi.core.handleWindowResize();
                        }, 500, 60 * 60 * 8);
                    }
                };


            };

            // 添加关联机构
            $scope.addRelevantOrgList = function () {
                var model = {
                    id: $scope.editModel.id,
                    name: $scope.editModel.name,
                    enterpriseAccountSetOrgList: []
                };

                if (!getEnterpriseAccountSetOrgListUI()) {
                    return;
                }

                model.enterpriseAccountSetOrgList = $scope.editModel.saveOrgList;

                enterpriseAccountService.addEnterpriseAccountSetOrg(model).success(function (data) {
                    if (data && data.result) {
                        $('#' + addEnterpriceAccountSetRelevantOrg).modal('hide');
                        SweetAlert.success($translate.instant('SaveSuccess'));
                        loadEnterpriseAccountSet();
                    } else {
                        swal($translate.instant('SaveFail'), $translate.instant(data.resultMsg), 'warning');
                    }
                });
            };

            // 编辑关联机构
            $scope.editRelevantOrg = function (model) {
                $scope.editModel = {};
                $scope.isAdd = false;
                var set = _.find($scope.enterpriseAccountSetList, function (num) {
                    return num.id === $scope.enterpriseAccountSetSelectID;
                });
                $scope.editModel.id = set.id;
                $scope.editModel.name = set.name;
                $scope.editModel.enterpriseAccountSetOrgList = [];

                var vmModel = angular.copy(model);
                $scope.editModel.enterpriseAccountSetOrgList.push(vmModel);
                setEditEnterpriseAccountSetOrgList();

                $('#' + updateEnterpriceAccountSetRelevantOrg).modal('show');
            };

            // 保存修改的关联机构
            $scope.updateRelevantOrg = function () {
                var updateModel = $scope.editModel.enterpriseAccountSetOrgList[0];
                updateModel.enterpriseAccountSetName = $scope.editModel.name;
                enterpriseAccountService.updateEnterpriseAccountSetOrg(updateModel).success(function (data) {

                    if (data && data.result) {
                        $('#' + updateEnterpriceAccountSetRelevantOrg).modal('hide');
                        SweetAlert.success($translate.instant('SaveSuccess'));
                        loadEnterpriseAccountSet();
                    } else {
                        swal($translate.instant('SaveFail'), $translate.instant(data.resultMsg), 'warning');
                    }
                });
            };

            // 删除关联机构
            $scope.deleteRelevantOrg = function (model) {
                SweetAlert.swal({
                        title: $translate.instant('Confirm') + $translate.instant('DeleteRelevantOrg') + '?',
                        text: $translate.instant('Confirm') + $translate.instant('DeleteRelevantOrg') + model.organizationName,
                        type: "warning",
                        showCancelButton: true,
                        confirmButtonColor: "#DD6B55",
                        confirmButtonText: $translate.instant('Confirm'),
                        cancelButtonText: $translate.instant('Cancel'),
                        closeOnConfirm: false,
                        closeOnCancel: true
                    },
                    function (isConfirm) {
                        if (isConfirm) {
                            // 选中
                            var deleteModel = {
                                id: model.enterpriseAccountSetID,
                                name: model.enterpriseAccountSetName,
                                enterpriseAccountSetOrgList: [],
                            };

                            deleteModel.enterpriseAccountSetOrgList.push(model);

                            enterpriseAccountService.deleteEnterpriseAccountSetOrg(deleteModel).success(function (or) {
                                if (or) {
                                    if (or.result === true) {
                                        SweetAlert.success($translate.instant('deleteOneRole'));
                                        loadEnterpriseAccountSet();
                                    } else {
                                        SweetAlert.warning($translate.instant(or.resultMsg));
                                    }
                                }
                            });
                        }

                    });
            };

            $scope.downEntepriseAccountTemplate = function () {
                enterpriseAccountService.downEntepriseAccountTemplate();


            };


            var getUserPermission = function () {

                var list = [];

                var userManageTemp = constant.adminPermission.basicData.enterpriseAccountSet;
                list.push(userManageTemp.addCode);
                list.push(userManageTemp.editCode);

                $scope.$root.checkUserPermissionList(list).success(function (data) {
                    $scope.hasAddPermission = data[userManageTemp.addCode];
                    $scope.hasEditPermission = data[userManageTemp.editCode];

                    afterGetPermission();
                });
            };


            // 获取权限之后显示
            var afterGetPermission = function () {
                $scope.downloadEnterpriseAccountUrl = apiInterceptor.webApiHostUrl + '/enterpriseAccountManage/downEntepriseAccountTemplate';
                $log.debug('EnterpriseAccountManageController.ctor()...');
                $scope.clearRepeatData = clearRepeatData;
                $scope.errorGridOptionsFun = errorGridOptionsFun;
                errorGridOptionsFun();
                $scope.enterpriceAccountList = [];
                $scope.search = search;
                $scope.newModel = newModel;
                $scope.save = save;
                $scope.load = load;
                $scope.modifyIsActive = modifyIsActive;
                $scope.hasEnterpriseAccountSet = true;
                $scope.acctPropArray = ['', $translate.instant('StandardAccountAcctPropAsset'),
                    $translate.instant('StandardAccountAcctPropDebt'),
                    $translate.instant('StandardAccountAcctPropCommon'),
                    $translate.instant('StandardAccountAcctPropInterest'),
                    $translate.instant('StandardAccountAcctPropCost'),
                    $translate.instant('StandardAccountAcctPropProfitAndLoss')
                ];
                $scope.directionMap = {
                    '1': $translate.instant('StandardAccountDebit'),
                    '-1': $translate.instant('StandardAccountCredit')
                };

                $scope.selectStandardAccount(defaultEnterpriceAccount);
                $scope.selectDirection = null;
                $scope.selectAcctProp = null;
                $scope.defaultEnterpriceAccount = defaultEnterpriceAccount;

                $scope.isActiveBtStr = $translate.instant(isActiveMap[false]);

                $scope.directionList = [{
                    id: 1,
                    name: $translate.instant('StandardAccountDebit')
                }, {
                    id: -1,
                    name: $translate.instant('StandardAccountCredit')
                },];

                $scope.acctPropList = [
                    {id: -1, name: ''},
                    {
                        id: 1,
                        name: $translate.instant('StandardAccountAcctPropAsset')
                    }, {
                        id: 2,
                        name: $translate.instant('StandardAccountAcctPropDebt')
                    }, {
                        id: 3,
                        name: $translate.instant('StandardAccountAcctPropCommon')
                    }, {
                        id: 4,
                        name: $translate.instant('StandardAccountAcctPropInterest')
                    }, {
                        id: 5,
                        name: $translate.instant('StandardAccountAcctPropCost')
                    }, {
                        id: 6,
                        name: $translate.instant('StandardAccountAcctPropProfitAndLoss')
                    },
                ];

                loadEnterpriseAccountSetList();

                $scope.singleSelected = {};

                $scope.singleClick = function (entity) {
                    if ($scope.singleSelected && entity.id === $scope.singleSelected.id && !entity.repeatSingleClick) {
                        $scope.isActiveBtStr = $translate.instant(isActiveMap[false]);
                        $scope.singleSelected = {};
                    } else {
                        $scope.isActiveBtStr = $translate.instant(isActiveMap[!entity.isActive]);

                        if (entity.repeatSingleClick) {
                            entity.isActiveStr = $translate.instant(isActivedMap[entity.isActive]);
                        }

                        $scope.singleSelected = entity;
                    }
                }

                $scope.gridOptions = {
                    rowHeight: 40,
                    selectionRowHeaderWidth: 40,
                    enableFullRowSelection: true,
                    enableRowSelection: true,
                    enableSorting: true,
                    enableFiltering: false,
                    enableColumnMenus: false,
                    enableRowHeaderSelection: false,
                    multiSelect: false,
                    enableHorizontalScrollbar: uiGridConstants.scrollbars.NEVER,
                    rowTemplate: '<div sglclick="grid.appScope.singleClick(row.entity)" >' +
                        '  <div ng-repeat="(colRenderIndex, col) in colContainer.renderedColumns track by col.colDef.name" class="ui-grid-cell" ng-class="{\'header-cell-class\':col.isRowHeader,\'single-row-select\':row.entity.id===grid.appScope.singleSelected.id,\'red-color\':row.entity.isHighLight }"  ui-grid-cell></div>' +
                        '</div>',

                    columnDefs: [{
                        field: 'code',
                        name: $translate.instant('EnterpriseAccountCode'),
                        width: '15%',
                        cellTemplate: '<div class="ui-grid-cell-contents"><span title="{{row.entity.code}}">{{row.entity.code}}</span></div>'
                    }, {
                        field: 'name',
                        name: $translate.instant('EnterpriseAccountName'),
                        width: '31%',
                        cellTemplate: '<div class="ui-grid-cell-contents"><span title="{{row.entity.name}}">{{row.entity.name}}</span></div>'
                    }, {
                        field: 'parent',
                        name: $translate.instant('StandardAccountSuperiorAccount'),
                        width: '32%',
                    }, {
                        field: 'directionStr',
                        name: $translate.instant('StandardAccountDirection'),
                        width: '11%',
                    }, {
                        field: 'acctPropStr',
                        name: $translate.instant('StandardAccountAccountTypes'),
                        width: '11%',
                    }

                        //, {
                        //    field: 'isMappedStr',
                        //    name: $translate.instant('IsMappedStatus'),
                        //    width: '11%'
                        //}

                        //, {
                        //    field: 'isActiveStr',
                        //    name: $translate.instant('IsActiveStatus'),
                        //    width: '11%'
                        //},

                    ],
                    onRegisterApi: function (gridApi) {
                        $scope.dataGridApi = gridApi;
                        $scope.dataGridApi.grid.registerRowsProcessor($scope.singleFilter, 200);
                        $interval(function () {
                            $scope.dataGridApi.core.handleWindowResize();
                        }, 500, 60 * 60 * 8);
                    }
                };

                $scope.singleFilter = function (renderableRows) {
                    var matcher = new RegExp($scope.searchEASText);
                    renderableRows.forEach(function (row) {

                        try {
                            var match = false;
                            ['code', 'name', 'parent', 'directionStr', 'acctPropStr'].forEach(function (field) {
                                if (row.entity[field] && row.entity[field].match(matcher)) {
                                    match = true;
                                }
                            });

                            if (!match) {
                                row.visible = false;
                            }
                        } catch (e) {
                            $log.debug('singleFilter-match:' + JSON.stringify(row.entity));
                        }
                    });
                    return renderableRows;
                };

                $scope.loadEnterpriceAccountList = loadEnterpriceAccountList;

                orgUIGridInit();
                $timeout(function () {

                    $scope.isLoadComplete = true;

                }, 500);

                $timeout(function () {
                    jumpToAccount();
                }, 600);

            };


            var KeyDown = function () { //屏蔽鼠标右键、Ctrl+n、shift+F10、F5刷新、退格键   
                //alert("ASCII代码是:"+event.keyCode);   
                if ((window.event.altKey) &&
                    ((window.event.keyCode == 37) || //屏蔽 Alt+ 方向键 ←   
                        (window.event.keyCode == 39))) { //屏蔽 Alt+ 方向键 →   
                    // alert("不准你使用ALT+方向键前进或后退网页!");

                    $('#addEnterpriceAccountPop').modal('hide');
                    $('#addEnterpriceAccountSetPop').modal('hide');
                    $('#importEnterpriceAccountSetPop').modal('hide');
                    $('#addEnterpriceAccountSetRelevantOrg').modal('hide');
                    $('#updateEnterpriceAccountSetRelevantOrg').modal('hide');
                    // $('#addEnterpriceAccountPop').modal('hide');

                    event.returnValue = true;
                }
                // if ((event.keyCode == 8) || //屏蔽退格删除键   
                //      (event.keyCode == 116) || //屏蔽 F5 刷新键   
                //       (event.keyCode == 112) || //屏蔽 F1 刷新键   
                //      (event.ctrlKey && event.keyCode == 82)) { //Ctrl + R   
                //      
                //     event.keyCode = 0; 
                //     event.returnValue = false;   
                //     // alert("不准你使用快捷!");
                // }
                // if ((event.ctrlKey) && (event.keyCode == 78)) //屏蔽 Ctrl+n   
                // {
                //     alert("ctrl + n");  
                //     event.returnValue = false;
                // }
                // if ((event.shiftKey) && (event.keyCode == 121)) //屏蔽 shift+F10   
                // {   alert(" shift+F10 ");  
                //     event.returnValue = false;   }
                // if (window.event.srcElement.tagName == "A" && window.event.shiftKey)    {    window.event.returnValue = false; //屏蔽 shift 加鼠标左键新开一网页   
                //         }

                // if ((window.event.altKey) && (window.event.keyCode == 115)) { //屏蔽Alt+F4   
                //         
                //     // alert('Alt+F4');
                //     //window.showModelessDialog("about:blank","","dialogWidth:1px;dialogheight:1px");   
                //     return false;
                // }
            }

            document.onkeydown = KeyDown;

            (function initialize() {
                //testErrorShowParams();

                getUserPermission();

            })();
        }
    ]);