#region

using System;
using System.Collections.Generic;
using System.Data;
using CSFrameworkV5.Common;
using CSFrameworkV5.Core;
using CSFrameworkV5.Interfaces;
using CSFrameworkV5.WCFContract;

#endregion

namespace CSFrameworkV5.WebRef.SystemModule
{
    public class WCF_User : WCF_Base<ISystemSecurityService>, IBridge_User
    {
        #region IBridge_User Members

        public List<AccountModel> SearchEx(string content, string ignoreGroup)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_SearchEx(loginTicket, content, ignoreGroup);
            });
        }

        public bool SetLockState(string account, bool isLock)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_SetLockState(loginTicket, account, isLock);
            });
        }

        public bool CopyPermission(string sourceUser, string targetUser)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_CopyPermission(loginTicket, sourceUser,
                    targetUser);
            });
        }

        public DataTable GetUserActionsList(string account)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var receivedData =
                    client.U_GetUserActionsList(loginTicket, account);
                return ZipTools.DecompressionDataSet(receivedData).Tables[0];
            });
        }

        public void Logout(LoginUser loginUser)
        {
            Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                client.U_Logout(loginTicket);
            });
        }

        public DataTable Login(LoginUser loginUser)
        {
            return Excute(client =>
            {
                var validationTicket = WebServiceSecurity.GetLoginTicket();
                var bsLoginUser = ZipTools.CompressionObject(loginUser);
                var receivedData =
                    client.U_Login(validationTicket, bsLoginUser);
                var ds = ZipTools.DecompressionDataSet(receivedData);
                return ds.Tables[0];
            });
        }

        public DataTable GetUserDirect(string account)
        {
            return Excute(client =>
            {
                var validationTicket = WebServiceSecurity.GetLoginTicket();
                var receivedData =
                    client.U_GetUserDirect(validationTicket, account, "");
                return ZipTools.DecompressionDataSet(receivedData).Tables[0];
            });
        }

        public DataTable GetUsers()
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var receivedData = client.U_GetUsers(loginTicket);
                return ZipTools.DecompressionDataSet(receivedData).Tables[0];
            });
        }

        public DataTable GetUser(string account)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var receivedData = client.U_GetUser(loginTicket, account);
                return ZipTools.DecompressionDataSet(receivedData).Tables[0];
            });
        }

        public DataTable GetUserGroups(string account)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var receivedData = client.U_GetUserGroups(loginTicket, account);
                return ZipTools.DecompressionDataSet(receivedData).Tables[0];
            });
        }

        public DataTable GetUserByNovellID(string novellAccount)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var receivedData =
                    client.U_GetUserByNovellID(loginTicket, novellAccount);
                return ZipTools.DecompressionDataSet(receivedData).Tables[0];
            });
        }

        public bool Update(DataSet ds)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var userData = ZipTools.CompressionDataSet(ds);
                return client.U_UpdateUser(loginTicket, userData);
            });
        }

        public bool DeleteUser(string account)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_DeleteUser(loginTicket, account);
            });
        }

        public bool ExistsUser(string account)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_ExistsUser(loginTicket, account);
            });
        }

        public bool ModifyPassword(string account, string OldPwd, string NewPwd)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_ModifyPassword(loginTicket, account, OldPwd,
                    NewPwd);
            });
        }

        public DataSet GetUserReportData(DateTime createDateFrom,
            DateTime createDateTo)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var bs = client.U_GetUserReportData(loginTicket, createDateFrom,
                    createDateTo);
                return ZipTools.DecompressionDataSet(bs);
            });
        }

        public DataTable GetUserRolesAll(string user)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var bs = client.U_GetUserRolesAll(loginTicket, user);
                return ZipTools.DecompressionDataSet(bs).Tables[0];
            });
        }

        public bool DestroyRights(string account)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_DestroyRights(loginTicket, account);
            });
        }

        public DataTable Search(string content)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var bs = client.U_Search(loginTicket, content);
                return ZipTools.DecompressionDataSet(bs).Tables[0];
            });
        }

        public DataTable GetUserRoles4Picker(string currentUser, string content)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var bs =
                    client.U_GetUserRoles4Picker(loginTicket, currentUser,
                        content);
                return ZipTools.DecompressionDataSet(bs).Tables[0];
            });
        }

        public DataTable GetUserRoles(string currentUser)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                var bs = client.U_GetUserRoles(loginTicket, currentUser);
                return ZipTools.DecompressionDataSet(bs).Tables[0];
            });
        }

        public bool TryLogin(string user, string encodedPwd)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_TryLogin(WebServiceSecurity.GetLoginTicket(),
                    user, encodedPwd);
            });
        }

        public bool DeleteUserRole(string account, string roleID)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_DeleteUserRole(loginTicket, account, roleID);
            });
        }

        public bool DeleteUserGroup(string account, string groupCode)
        {
            return Excute(client =>
            {
                var loginTicket =
                    WebServiceSecurity.EncryptLoginer(Loginer.CurrentUser);
                return client.U_DeleteUserGroup(loginTicket, account,
                    groupCode);
            });
        }

        public bool insrer(string account, string OldPwd, string NewPwd)
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}