#region

using System;
using System.Collections.Generic;
using System.Data;
using System.ServiceModel;
using CSFrameworkV5.Common;
using CSFrameworkV5.Core;
using CSFrameworkV5.DataAccess;
using CSFrameworkV5.Interfaces;
using CSFrameworkV5.Interfaces.InterfaceModels;
using CSFrameworkV5.Models;
using tb_MyGroupUser = CSFrameworkV5.Interfaces.tb_MyGroupUser;

#endregion

namespace CSFrameworkV5.WCFContract.WCF_Class
{
    [ServiceBehavior(IncludeExceptionDetailInFaults = true)]
    [WCF_ExceptionBehaviour(typeof(WCF_ExceptionHandler))]
    public class SystemSecurityService : ISystemSecurityService
    {
        public string Test()
        {
            return "test ok!";
        }

        #region 用户管理(dalUser)的方法

        #region 用户操作，同步更新缓存的用户数据, ActivityUserCache

        public bool U_SetLockState(byte[] loginTicket, string account,
            bool isLock)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var ok = new dalUser(loginer).SetLockState(account, isLock);
                if (ok && isLock)
                    if (ok)
                        ActivityUserCache.SyncRemoveUserCache(account);

                return ok;
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_DeleteUser(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var ok = new dalUser(loginer).DeleteUser(account);
                if (ok) ActivityUserCache.SyncRemoveUserCache(account);

                return ok;
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_UpdateUser(byte[] loginTicket, byte[] userData)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                var data = ZipTools.DecompressionDataSet(userData);
                var user = data.Tables[tb_MyUser.__TableName].Copy(); //备份
                var success = new dalUser(loginer).Update(data);
                if (success) ActivityUserCache.SyncUserCache(user); //同步用户缓存数据

                return success;
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_ModifyPassword(byte[] loginTicket, string account,
            string OldPwd, string NewPwd)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var ok =
                    new dalUser(loginer).ModifyPassword(account, OldPwd,
                        NewPwd);
                if (ok) ActivityUserCache.SyncUpdateUserCache(account, NewPwd);

                return ok;
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        #endregion

        public bool U_CopyPermission(byte[] loginTicket, string sourceUser,
            string targetUser)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUser(loginer).CopyPermission(sourceUser,
                    targetUser);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_DeleteUserRole(byte[] loginTicket, string account,
            string roleID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUser(loginer).DeleteUserRole(account, roleID);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_DeleteUserGroup(byte[] loginTicket, string account,
            string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUser(loginer).DeleteUserGroup(account, groupCode);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_DestroyRights(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                return new dalUser(loginer).DestroyRights(account);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserActionsList(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                var data = new dalUser(loginer).GetUserActionsList(account);
                return ZipTools.CompressionObject(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUsers(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                var data = new dalUser(loginer).GetUsers();
                return ZipTools.CompressionObject(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserReportData(byte[] loginTicket,
            DateTime createDateFrom, DateTime createDateTo)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                var data =
                    new dalUser(loginer).GetUserReportData(createDateFrom,
                        createDateTo);
                return ZipTools.CompressionObject(data);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUser(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                var data = new dalUser(loginer).GetUser(account);
                return ZipTools.CompressionObject(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserGroups(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                var data = new dalUser(loginer).GetUserGroups(account);
                return ZipTools.CompressionObject(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserByNovellID(byte[] loginTicket,
            string novellAccount)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                var data =
                    new dalUser(loginer).GetUserByNovellID(novellAccount);
                return ZipTools.CompressionObject(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_TryLogin(byte[] loginTicket, string user,
            string encodedPwd)
        {
            try
            {
                WebSecurity.ValidateLoginIdentity(loginTicket);
                return new dalUser(null).TryLogin(user, encodedPwd);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool U_ExistsUser(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);

                return new dalUser(loginer).ExistsUser(account);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public void U_Logout(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var user = new LoginUser(loginer);
                new dalUser(loginer).Logout(user);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_Login(byte[] validationTicket, byte[] loginUser)
        {
            try
            {
                var pass = WebSecurity.ValidateLoginIdentity(validationTicket);

                //检查校验码成功,有效的登录请求.
                if (pass)
                {
                    var userInfo =
                        ZipTools.DecompressionObject(loginUser) as LoginUser;

                    var user = new dalUser(null).Login(userInfo); //检查用户名及密码

                    return ZipTools.CompressionDataSet(
                        ServerLibrary.TableToDataSet(user));
                }

                return null;
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserDirect(byte[] validationTicket, string account,
            string DBName)
        {
            try
            {
                var pass = WebSecurity.ValidateLoginIdentity(validationTicket);

                //检查校验码成功,有效的登录请求.
                if (pass)
                {
                    var dt = new dalUser(null).GetUserDirect(account);
                    return ZipTools.CompressionDataSet(
                        ServerLibrary.TableToDataSet(dt));
                }

                return null;
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserRolesAll(byte[] loginTicket, string user)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var data = new dalUser(loginer).GetUserRolesAll(user);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_Search(byte[] loginTicket, string content)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var data = new dalUser(loginer).Search(content);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public List<AccountModel> U_SearchEx(byte[] loginTicket, string content,
            string ignoreGroup)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUser(loginer).SearchEx(content, ignoreGroup);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserRoles4Picker(byte[] loginTicket,
            string currentUser, string content)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var data =
                    new dalUser(loginer).GetUserRoles4Picker(loginer.Account,
                        content);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] U_GetUserRoles(byte[] loginTicket, string currentUser)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var data = new dalUser(loginer).GetUserRoles(currentUser);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(data));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        #endregion

        #region 用户组管理(dalUserGroup)的方法

        public DataTable G_GetGroupUsers4TreeList(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserGroup(loginer).GetGroupUsers4TreeList();
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetGroupByUser(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetGroupByUser(account);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_Search(byte[] loginTicket, string GroupCode,
            string GroupName, string AttributeCodes,
            string Owner1, string OwnerTel1)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).Search(GroupCode, GroupName,
                    AttributeCodes, Owner1, OwnerTel1);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool G_SetOwner(byte[] loginTicket, string ownerType,
            string groupCode, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserGroup(loginer).SetOwner(ownerType, groupCode,
                    account);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public int G_AddGroupUsers(byte[] loginTicket,
            List<tb_MyGroupUser> data)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserGroup(loginer).Add(data);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool G_DeleteGroupUser(byte[] loginTicket, string groupCode,
            string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserGroup(loginer).DeleteGroupUser(groupCode,
                    account);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetUserGroup(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetSummaryData();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetUserGroupByCode(byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetDataByKey(groupCode);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public DataTable G_GetMyGroups4Picker(byte[] loginTicket,
            string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetMyGroups4Picker(account);
                return dt;
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetFormTagCustomName(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalPermission(loginer).GetFormTagCustomName();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool G_CheckNoExists(byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserGroup(loginer).CheckNoExists(groupCode);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool G_DeleteGroupRights(byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserGroup(loginer).DeleteGroupRights(groupCode);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool G_DeleteGroupData(byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserGroup(loginer).DeleteGroupData(groupCode);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetGroup4Picker(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetGroup4Picker();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetGroupUsers(byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetGroupUsers(groupCode);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetGroupUsers4Picker(byte[] loginTicket,
            string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt =
                    new dalUserGroup(loginer).GetGroupUsers4Picker(groupCode);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetGroupRoles4Picker(byte[] loginTicket,
            string currentGroupCode, string currentUser)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt =
                    new dalUserGroup(loginer).GetGroupRoles4Picker(
                        currentGroupCode, currentUser);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetGroupRoles(byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetGroupRoles(groupCode);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] G_GetGroupActions(byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserGroup(loginer).GetGroupActions(groupCode);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        #endregion

        #region 权限公共方法 dalPermission

        public DataTable GetMenuItems(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserCustomAction(loginer).GetMenuItems();
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public int DeleteAllMenu(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).DeleteAllMenu();
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public DataTable GetMenuByUser(byte[] loginTicket, string account,
            string dataSetID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).GetMenuByUser(account,
                    dataSetID);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool IsUserBelongRole(byte[] loginTicket, string user,
            string roleID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer)
                    .IsUserBelongRole(user, roleID);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool IsOwner(byte[] loginTicket, string docUser, string leader)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).IsOwner(docUser, leader);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetLookupMenu(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalPermission(loginer).GetLookupMenu();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetOwnersByMenu(byte[] loginTicket, string menuID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var ds = new dalPermission(loginer).GetOwnersByMenu(menuID);
                return ZipTools.CompressionDataSet(ds);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool Common_Init(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).Init();
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool Common_IsExistsModule(byte[] loginTicket, int moduleID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).IsExistsModule(moduleID);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetModuleData(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalPermission(loginer).GetModuleData();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetFormTagName(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalPermission(loginer).GetFormTagName();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetFormTagCustomName(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalPermission(loginer).GetFormTagCustomName();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetChildUser(byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalPermission(loginer).GetChildUser(account);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetRoleOwners(byte[] loginTicket, string roleID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var ds = new dalPermission(loginer).GetRoleOwners(roleID);
                return ZipTools.CompressionDataSet(ds);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetRoleAction(byte[] loginTicket, string roleID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalRole(loginer).GetRoleAction(roleID);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetActionData(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalActions(loginer).GetActionData();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetMenuData(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalMenu(loginer).GetSummaryData();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetMenuPicker(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalMenu(loginer).GetMenuPicker();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetRoleData(byte[] loginTicket)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalRole(loginer).GetRoleData();
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_GetUserActionsList(byte[] loginTicket,
            string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUser(loginer).GetUserActionsList(account);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool Common_IsExistsAction(byte[] loginTicket, int actionValue)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalActions(loginer).IsExistsAction(actionValue);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool Common_IsExistsRole(byte[] loginTicket, string roleID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalRole(loginer).IsExistsRole(roleID);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public int Common_GetUserActions(byte[] loginTicket, string account,
            string menuName)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUser(loginer).GetUserActions(account, menuName);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public byte[] Common_SearchUserRole(byte[] loginTicket, string account,
            string roleID,
            DateTime expireDateFrom, DateTime expireDateTo)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                var dt = new dalUserRole(loginer).SearchUserRole(account,
                    roleID, expireDateFrom, expireDateTo);
                return ZipTools.CompressionDataSet(
                    ServerLibrary.TableToDataSet(dt));
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public DataTable Common_GetDataPermissionConfigByGroup(
            byte[] loginTicket, string groupCode)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer)
                    .GetDataPermissionConfigByGroup(groupCode);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public DataTable Common_GetDataPermissionConfigByUser(
            byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).GetDataPermissionConfigByUser(
                    account);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public List<DataPermissionModel> Common_GetDataPermissionConfig(
            byte[] loginTicket, string account)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).GetDataPermissionConfig(
                    account);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool Common_DeleteUserRole(byte[] loginTicket, string account,
            string roleID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalUserRole(loginer).DeleteUserRole(account, roleID);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public DataTable Common_QueryRole(byte[] loginTicket, string roleType,
            string content)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).Query(roleType, content);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public DataTable Common_GetGridPermission(byte[] loginTicket,
            string userID)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).GetGridPermission(userID);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool Common_SaveGridPermission(byte[] loginTicket,
            DataTable data)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).SaveGridPermission(data);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public bool Common_SaveDataPermission(byte[] loginTicket,
            DataTable data)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).SaveDataPermission(data);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        public string Common_GetGridPermissionById(byte[] loginTicket,
            string userID, string viewId)
        {
            try
            {
                var loginer = WebSecurity.ValidateLoginer(loginTicket);
                return new dalPermission(loginer).GetGridPermissionById(userID,
                    viewId);
            }
            catch (Exception ex)
            {
                throw new FaultException(ex.Message);
            }
        }

        #endregion
    }
}