C# MailServer.WSqlCommand类代码示例

        /// <summary>
        /// Stores IMAP message flags (\seen,\draft, ...).
        /// </summary>
        /// <param name="accessingUser">User who accesses this method. 
        /// User needs r permission to call this method or Exception is thrown. 
        /// There is special user 'system' for which permission check is skipped.</param>
        /// <param name="folderOwnerUser">User who's folder it is.</param>
        /// <param name="folder">Folder which message flags to store. For example: Inbox,Public Folders/Documnets .</param>
        /// <param name="message">Fix ME: ???</param>
        /// <param name="msgFlags">Message flags to store.</param>
        public void StoreMessageFlags(string accessingUser,string folderOwnerUser,string folder,LumiSoft.Net.IMAP.Server.IMAP_Message message,IMAP_MessageFlags msgFlags)
        {
            /* Implementation notes:
                *) Validate values. Throw ArgumnetExcetion if invalid values.
                *) Ensure that user exists.
                *) Normalize folder. Remove '/' from folder start and end, ... .
                *) Do Shared Folders mapping.
                *) Ensure that folder exists. Throw Exception if don't.
                *) Remove all message flags which permissions user doesn't have.
                *) Store message.
            */

            //--- Validate values -------------------//
            ArgsValidator.ValidateUserName(folderOwnerUser);
            ArgsValidator.ValidateFolder(folder);
            ArgsValidator.ValidateNotNull(message);
            //---------------------------------------//

            // Ensure that user exists.
            if(!UserExists(folderOwnerUser)){
                throw new Exception("User '" + folderOwnerUser + "' doesn't exist !");
            }

            // Normalize folder. Remove '/' from folder start and end.
            folder = API_Utlis.NormalizeFolder(folder);

            // Do Shared Folders mapping.
            string originalFolder = folder;
            SharedFolderMapInfo mappedFolder = MapSharedFolder(originalFolder);
            if(mappedFolder.IsSharedFolder){
                folderOwnerUser = mappedFolder.FolderOnwer;
                folder = mappedFolder.Folder;

                if(folderOwnerUser == "" || folder == ""){
                    throw new ArgumentException("Specified root folder '" + originalFolder + "' isn't accessible !");
                }
            }

            // Ensure that folder exists. Throw Exception if don't.
            if(!FolderExists(folderOwnerUser + "/" + folder)){
                throw new Exception("Folder '" + folder + "' doesn't exist !");
            }

            // Remove all message flags which permissions user doesn't have.
            if(accessingUser != "system"){
                IMAP_ACL_Flags userACL = GetUserACL(folderOwnerUser,folder,accessingUser);
                if((userACL & IMAP_ACL_Flags.s) == 0){
                    msgFlags &= ~IMAP_MessageFlags.Seen;
                }
                else if((userACL & IMAP_ACL_Flags.d) == 0){
                    msgFlags &= ~IMAP_MessageFlags.Deleted;
                }
                else if((userACL & IMAP_ACL_Flags.s) == 0){
                    msgFlags &= (~IMAP_MessageFlags.Answered | ~IMAP_MessageFlags.Draft | ~IMAP_MessageFlags.Flagged);
                }
            }

            //--- Store message flags
            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_StoreMessageFlags")){
                sqlCmd.AddParameter("_userName"     ,NpgsqlDbType.Varchar,folderOwnerUser);
                sqlCmd.AddParameter("_folder"       ,NpgsqlDbType.Varchar,folder);
                sqlCmd.AddParameter("_messageID"    ,NpgsqlDbType.Varchar,message.ID);
                sqlCmd.AddParameter("_messageFlags" ,NpgsqlDbType.Integer,(int)message.Flags);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// Creates new IMAP folder.
        /// </summary>
        /// <param name="accessingUser">User who accesses this method. 
        /// User needs r permission to call this method or Exception is thrown. 
        /// There is special user 'system' for which permission check is skipped.</param>
        /// <param name="folderOwnerUser">User who's folder it is.</param>
        /// <param name="folder">Folder what contains message to copy. For example: Inbox,Public Folders/Documnets .</param>
        public void CreateFolder(string accessingUser,string folderOwnerUser,string folder)
        {
            /* Implementation notes:
                *) Validate values. Throw ArgumnetExcetion if invalid values.
                *) Ensure that user exists.
                *) Normalize folder. Remove '/' from folder start and end, ... .
                *) Do Shared Folders mapping.
                *) Ensure that folder doesn't exists. Throw Exception if don't.
                *) See if user has sufficient permissions. User requires 'c' permission.
                    There is builtin user system, skip ACL for it.
                *) Create folder.
            */

            //--- Validate values -------------------//
            ArgsValidator.ValidateUserName(folderOwnerUser);
            ArgsValidator.ValidateFolder(folder);
            //---------------------------------------//

            // Ensure that user exists.
            if(!UserExists(folderOwnerUser)){
                throw new Exception("User '" + folderOwnerUser + "' doesn't exist !");
            }

            // Normalize folder. Remove '/' from folder start and end.
            folder = API_Utlis.NormalizeFolder(folder);

            // Do Shared Folders mapping.
            string originalFolder = folder;
            SharedFolderMapInfo mappedFolder = MapSharedFolder(originalFolder);
            if(mappedFolder.IsSharedFolder){
                folderOwnerUser = mappedFolder.FolderOnwer;
                folder = mappedFolder.Folder;

                if(folderOwnerUser == "" || folder == ""){
                    throw new ArgumentException("Specified root folder '" + originalFolder + "' isn't accessible !");
                }
            }

            // Ensure that folder doesn't exists. Throw Exception if don't.
            if(FolderExists(folderOwnerUser + "/" + folder)){
                throw new Exception("Folder '" + folder + "' already exist !");
            }

            // See if user has sufficient permissions. User requires 'c' permission.
            //  There is builtin user system, skip ACL for it.
            if(accessingUser.ToLower() != "system"){
                IMAP_ACL_Flags acl = GetUserACL(folderOwnerUser,folder,accessingUser);
                if((acl & IMAP_ACL_Flags.c) == 0){
                    throw new InsufficientPermissionsException("Insufficient permissions for folder '" + accessingUser + "/" + folder + "' !");
                }
            }

            //--- Create folder
            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_CreateFolder")){
                sqlCmd.AddParameter("_folderID",NpgsqlDbType.Varchar,Guid.NewGuid().ToString());
                sqlCmd.AddParameter("_userName",NpgsqlDbType.Varchar,folderOwnerUser);
                sqlCmd.AddParameter("_folder"  ,NpgsqlDbType.Varchar,folder);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// Deletes specified filter.
        /// </summary>
        /// <param name="filterID">FilterID of the filter which to delete.</param>
        public void DeleteFilter(string filterID)
        {
            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_DeleteFilter")){
                sqlCmd.AddParameter("_filterID" ,NpgsqlDbType.Varchar,filterID);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// AAdds new remote pop3 server to user.
        /// </summary>
        /// <param name="serverID">Server ID. Suggested value is Guid.NewGuid() .</param>
        /// <param name="userName">User name. Use <see cref="IMailServerApi.GetUsers">GetUsers()</see> to get valid values.</param>
        /// <param name="description">Remote server description.</param>
        /// <param name="remoteServer">Remote server name.</param>
        /// <param name="remotePort">Remote server port.</param>
        /// <param name="remoteUser">Remote server user name.</param>
        /// <param name="remotePassword">Remote server password.</param>
        /// <param name="useSSL">Specifies if SSL must be used to connect to remote server.</param>
        /// <param name="enabled">Specifies if remote server is enabled.</param>
        /// <remarks>Throws exception if specified user remote server already exists.</remarks>
        public void AddUserRemoteServer(string serverID,string userName,string description,string remoteServer,int remotePort,string remoteUser,string remotePassword,bool useSSL,bool enabled)
        {
            if(serverID.Length == 0){
                throw new Exception("You must specify serverID");
            }
            if(userName.Length == 0){
                throw new Exception("You must specify userName");
            }

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_AddUserRemoteServer")){
                sqlCmd.AddParameter("_serverID"       ,NpgsqlDbType.Varchar,serverID);
                sqlCmd.AddParameter("_userName"       ,NpgsqlDbType.Varchar,userName);
                sqlCmd.AddParameter("_description"    ,NpgsqlDbType.Varchar,description);
                sqlCmd.AddParameter("_remoteServer"   ,NpgsqlDbType.Varchar,remoteServer);
                sqlCmd.AddParameter("_remotePort"     ,NpgsqlDbType.Integer,remotePort);
                sqlCmd.AddParameter("_remoteUserName" ,NpgsqlDbType.Varchar,remoteUser);
                sqlCmd.AddParameter("_remotePassword" ,NpgsqlDbType.Varchar,remotePassword);
                sqlCmd.AddParameter("_useSSL"         ,NpgsqlDbType.Boolean,useSSL);
                sqlCmd.AddParameter("_enabled"        ,NpgsqlDbType.Boolean,enabled);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// Authenticates user.
        /// </summary>
        /// <param name="userName">User name.</param>
        /// <param name="passwData">Password data.</param>
        /// <param name="authData">Authentication specific data(as tag).</param>
        /// <param name="authType">Authentication type.</param>
        /// <returns></returns>
        public DataSet AuthUser(string userName,string passwData,string authData,AuthType authType)
        {
            DataSet retVal = new DataSet();
            DataTable dt = retVal.Tables.Add("Result");
            dt.Columns.Add("Result");
            dt.Columns.Add("ReturnData");
            DataRow drx = dt.NewRow();
            drx["Result"] = "false";
            drx["ReturnData"] = "";
            dt.Rows.Add(drx);

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_GetUserProperties")){
                sqlCmd.AddParameter("_userName",NpgsqlDbType.Varchar,userName);

                DataSet ds = sqlCmd.Execute();
                ds.Tables[0].TableName = "Users";

                if(ds.Tables["Users"].Rows.Count > 0){
                    string password = ds.Tables["Users"].Rows[0]["PASSWORD"].ToString().ToLower();

                    switch(authType)
                    {
                        case AuthType.APOP:
                            if(AuthHelper.Apop(password,authData) == passwData){
                                drx["Result"] = "true";
                                return retVal;
                            }
                            break;

                        case AuthType.CRAM_MD5:
                            if(AuthHelper.Cram_Md5(password,authData) == passwData){
                                drx["Result"] = "true";
                                return retVal;
                            }
                            break;

                        case AuthType.DIGEST_MD5:
                            string realm      = "";
                            string nonce      = "";
                            string cnonce     = "";
                            string digest_uri = "";
                            foreach(string clntRespParam in authData.Split(',')){
                                if(clntRespParam.StartsWith("realm=")){
                                    realm = clntRespParam.Split(new char[]{'='},2)[1].Replace("\"","");
                                }
                                else if(clntRespParam.StartsWith("nonce=")){
                                    nonce = clntRespParam.Split(new char[]{'='},2)[1].Replace("\"","");
                                }
                                else if(clntRespParam.StartsWith("cnonce=")){
                                    cnonce = clntRespParam.Split(new char[]{'='},2)[1].Replace("\"","");
                                }
                                else if(clntRespParam.StartsWith("digest-uri=")){
                                    digest_uri = clntRespParam.Split(new char[]{'='},2)[1].Replace("\"","");
                                }
                            }

                            if(passwData == AuthHelper.Digest_Md5(true,realm,userName,password,nonce,cnonce,digest_uri)){
                                string returnData = AuthHelper.Digest_Md5(false,realm,userName,password,nonce,cnonce,digest_uri);

                                drx["Result"] = "true";
                                drx["ReturnData"] = returnData;
                                return retVal;
                            }

                            break;

                        case AuthType.Plain:
                            if(password == passwData.ToLower()){
                                drx["Result"] = "true";
                                return retVal;
                            }
                            break;
                    }
                }
            }

            return retVal;
        }

        /// <summary>
        /// Adds new user to specified domain.
        /// </summary>
        /// <param name="userID">User ID. Suggested value is Guid.NewGuid() .</param>
        /// <param name="userName">User login name.</param>
        /// <param name="fullName">User full name.</param> 
        /// <param name="password">User login password.</param>
        /// <param name="description">User description.</param>
        /// <param name="domainName">Domain where to add user. Use <see cref="IMailServerApi.GetDomains">GetDomains()</see> to get valid values.</param>
        /// <param name="mailboxSize">Maximum mailbox size.</param>
        /// <param name="enabled">Sepcifies if user is enabled.</param>
        /// <param name="permissions">Specifies user permissions.</param>
        /// <remarks>Throws exception if specified user already exists.</remarks>
        public void AddUser(string userID,string userName,string fullName,string password,string description,string domainName,int mailboxSize,bool enabled,UserPermissions_enum permissions)
        {
            if(userID.Length == 0){
                throw new Exception("You must specify userID");
            }
            if(userName.Length == 0){
                throw new Exception("You must specify userName");
            }

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_AddUser")){
                sqlCmd.AddParameter("_userID"      ,NpgsqlDbType.Varchar,userID);
                sqlCmd.AddParameter("_fullName"    ,NpgsqlDbType.Varchar,fullName);
                sqlCmd.AddParameter("_userName"    ,NpgsqlDbType.Varchar,userName);
                sqlCmd.AddParameter("_password"    ,NpgsqlDbType.Varchar,password);
                sqlCmd.AddParameter("_description" ,NpgsqlDbType.Varchar,description);
                sqlCmd.AddParameter("_domainName"  ,NpgsqlDbType.Varchar,domainName);
                sqlCmd.AddParameter("_mailboxSize" ,NpgsqlDbType.Integer,mailboxSize);
                sqlCmd.AddParameter("_enabled"     ,NpgsqlDbType.Boolean,enabled);
                sqlCmd.AddParameter("_permissions" ,NpgsqlDbType.Integer,permissions);

                DataSet ds = sqlCmd.Execute();
                ds.Tables[0].TableName = "Users";
            }
        }

        /// <summary>
        /// Adds new user message rule.
        /// </summary>
        /// <param name="userID">User who owns specified rule.</param>
        /// <param name="ruleID">Rule ID. Guid.NewID().ToString() is suggested.</param>
        /// <param name="cost">Cost specifies in what order rules are processed. Costs with lower values are processed first.</param>
        /// <param name="enabled">Specifies if rule is enabled.</param>
        /// <param name="checkNextRule">Specifies when next rule is checked.</param>
        /// <param name="description">Rule description.</param>
        /// <param name="matchExpression">Rule match expression.</param>
        public void AddUserMessageRule(string userID,string ruleID,long cost,bool enabled,GlobalMessageRule_CheckNextRule_enum checkNextRule,string description,string matchExpression)
        {
            if(userID == null || userID == ""){
                throw new Exception("Invalid userID value, userID can't be '' or null !");
            }
            if(ruleID == null || ruleID == ""){
                throw new Exception("Invalid ruleID value, ruleID can't be '' or null !");
            }

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_AddUserMessageRule")){
                sqlCmd.AddParameter("_userID"          ,NpgsqlDbType.Varchar,userID);
                sqlCmd.AddParameter("_ruleID"          ,NpgsqlDbType.Varchar,ruleID);
                sqlCmd.AddParameter("_cost"            ,NpgsqlDbType.Bigint  ,cost);
                sqlCmd.AddParameter("_enabled"         ,NpgsqlDbType.Boolean ,enabled);
                sqlCmd.AddParameter("_checkNextRule"   ,NpgsqlDbType.Integer ,checkNextRule);
                sqlCmd.AddParameter("_description"     ,NpgsqlDbType.Varchar,description);
                sqlCmd.AddParameter("_matchExpression" ,NpgsqlDbType.Bytea   ,System.Text.Encoding.Default.GetBytes(matchExpression));

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// Updates specified mailing list.
        /// </summary>
        /// <param name="mailingListID">Mailing list ID.</param>
        /// <param name="mailingListName">Mailing list name name. Use <see cref="IMailServerApi.GetMailingLists">GetMailingLists()</see> to get valid values.</param>
        /// <param name="description">Mailing list description.</param>
        /// <param name="domainName">Domain name. Use <see cref="IMailServerApi.GetDomains">>GetUsers()</see> to get valid values.</param>
        /// <param name="enabled">Specifies if mailing list is enabled.</param>
        public void UpdateMailingList(string mailingListID,string mailingListName,string description,string domainName,bool enabled)
        {
            if(mailingListName.Length == 0){
                throw new Exception("You must specify mailingListName");
            }

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_UpdateMailingList")){
                sqlCmd.AddParameter("_mailingListID"   ,NpgsqlDbType.Varchar,mailingListID);
                sqlCmd.AddParameter("_mailingListName" ,NpgsqlDbType.Varchar,mailingListName);
                sqlCmd.AddParameter("_description"     ,NpgsqlDbType.Varchar,description);
                sqlCmd.AddParameter("_domainName"      ,NpgsqlDbType.Varchar,domainName);
                sqlCmd.AddParameter("_enabled"         ,NpgsqlDbType.Boolean,enabled);

                DataSet ds = sqlCmd.Execute();
            }
        }

 /// <summary>
 /// Updates recycle bin settings.
 /// </summary>
 /// <param name="deleteToRecycleBin">Specifies if deleted messages are store to recycle bin.</param>
 /// <param name="deleteMessagesAfter">Specifies how old messages will be deleted.</param>
 public void UpdateRecycleBinSettings(bool deleteToRecycleBin,int deleteMessagesAfter)
 {
     using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_UpdateRecycleBinSettings")){
         sqlCmd.AddParameter("_deleteToRecycleBin" ,NpgsqlDbType.Boolean,deleteToRecycleBin);
         sqlCmd.AddParameter("_deleteMessagesAfter",NpgsqlDbType.Integer,deleteMessagesAfter);
         DataSet ds = sqlCmd.Execute();
     }
 }

        /// <summary>
        /// Updates specified filter.
        /// </summary>		
        /// <param name="filterID">FilterID which to update.</param>
        /// <param name="description">Filter description</param>
        /// <param name="type">Filter type. Eg. ISmtpMessageFilter.</param>
        /// <param name="assembly">Assembly with full location. Eg. C:\MailServer\Filters\filter.dll .</param>
        /// <param name="className">Filter full class name, wih namespace. Eg. LumiSoft.MailServer.Fileters.Filter1 .</param>
        /// <param name="cost">Filters are sorted by cost and proccessed with cost value. Smallest cost is proccessed first.</param>
        /// <param name="enabled">Specifies if filter is enabled.</param>
        /// <returns></returns>
        public void UpdateFilter(string filterID,string description,string type,string assembly,string className,long cost,bool enabled)
        {
            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_UpdateFilter")){
                sqlCmd.AddParameter("_filterID"    ,NpgsqlDbType.Varchar,filterID);
                sqlCmd.AddParameter("_description" ,NpgsqlDbType.Varchar,description);
                sqlCmd.AddParameter("_type"        ,NpgsqlDbType.Varchar,type);
                sqlCmd.AddParameter("_assembly"    ,NpgsqlDbType.Varchar,assembly);
                sqlCmd.AddParameter("_className"   ,NpgsqlDbType.Varchar,className);
                sqlCmd.AddParameter("_cost"        ,NpgsqlDbType.Bigint ,cost);
                sqlCmd.AddParameter("_enabled"     ,NpgsqlDbType.Boolean,enabled);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// Updates user group info.
        /// </summary>
        /// <param name="groupID">Group ID.</param>
        /// <param name="groupName">Group name.</param>
        /// <param name="description">Group description.</param>
        /// <param name="enabled">Specifies if group is enabled.</param>
        public void UpdateGroup(string groupID,string groupName,string description,bool enabled)
        {
            /* Implementation notes:
                *) Validate values. Throw ArgumnetExcetion if invalid values.
                *) Ensure that group with specified ID does exist.  Throw Exception if doesn't.
                *) If group name is changed, ensure that new group name won't conflict
                   any other group or user name. Throw Exception if does.
                *) Udpate group.
            */

            //--- Validate values --------------------//
            if(groupID == null || groupID == ""){
                throw new Exception("Invalid groupID value, groupID can't be '' or null !");
            }
            ArgsValidator.ValidateUserName(groupName);
            ArgsValidator.ValidateNotNull(description);
            //----------------------------------------//

            /* We handle these is SQL, sql throws Excption

            *) Ensure that group with specified ID does exist.  Throw Exception if doesn't.
            *) If group name is changed, ensure that new group name won't conflict
               any other group or user name. Throw Exception if does.
            */

            // Update group
            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_UpdateGroup")){
                sqlCmd.AddParameter("_groupID"     ,NpgsqlDbType.Varchar,groupID);
                sqlCmd.AddParameter("_groupName"   ,NpgsqlDbType.Varchar,groupName);
                sqlCmd.AddParameter("_description" ,NpgsqlDbType.Varchar,description);
                sqlCmd.AddParameter("_enabled"     ,NpgsqlDbType.Boolean,enabled);

                DataSet ds = sqlCmd.Execute();
                ds.Tables[0].TableName = "Groups";
            }
        }

        /// <summary>
        /// Updates specified domain data.
        /// </summary>
        /// <param name="domainID">Domain ID which to update.</param>
        /// <param name="domainName">Domain name.</param>
        /// <param name="description">Domain description.</param>
        public void UpdateDomain(string domainID,string domainName,string description)
        {
            if(domainID.Length == 0){
                throw new Exception("You must specify domainID");
            }
            ArgsValidator.ValidateDomainName(domainName);

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_UpdateDomain")){
                sqlCmd.AddParameter("_domainID"   ,NpgsqlDbType.Varchar,domainID);
                sqlCmd.AddParameter("_domainName" ,NpgsqlDbType.Varchar,domainName);
                sqlCmd.AddParameter("_description",NpgsqlDbType.Varchar,description);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// UnSubscribes IMAP folder.
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="folder"></param>
        public void UnSubscribeFolder(string userName,string folder)
        {
            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_UnSubscribeFolder")){
                sqlCmd.AddParameter("_userName",NpgsqlDbType.Varchar,userName);
                sqlCmd.AddParameter("_folder"  ,NpgsqlDbType.Varchar,folder);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// Add new email address to specified mailing list.
        /// </summary>
        /// <param name="addressID">Address ID. Suggested value is Guid.NewGuid() .</param>
        /// <param name="mailingListName">Mailing list name name. Use <see cref="IMailServerApi.GetMailingLists">GetMailingLists()</see> to get valid values.</param>
        /// <param name="address">Mailing list member address.</param>
        /// <remarks>Throws exception if specified mailing list member already exists.</remarks>
        public void AddMailingListAddress(string addressID,string mailingListName,string address)
        {
            if(addressID.Length == 0){
                throw new Exception("You must specify addressID");
            }
            if(mailingListName.Length == 0){
                throw new Exception("You must specify mailingListName");
            }
            if(address.Length == 0){
                throw new Exception("You must specify address");
            }

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_AddMailingListAddress")){
                sqlCmd.AddParameter("_addressID"       ,NpgsqlDbType.Varchar,addressID);
                sqlCmd.AddParameter("_mailingListName" ,NpgsqlDbType.Varchar,mailingListName);
                sqlCmd.AddParameter("_address"         ,NpgsqlDbType.Varchar,address);

                DataSet ds = sqlCmd.Execute();
            }
        }

        /// <summary>
        /// Adds new IP security entry.
        /// </summary>
        /// <param name="id">IP security entry ID.</param>
        /// <param name="enabled">Specifies if IP security entry is enabled.</param>
        /// <param name="description">IP security entry description text.</param>
        /// <param name="service">Specifies service for what security entry applies.</param>
        /// <param name="action">Specifies what action done if IP matches to security entry range.</param>
        /// <param name="startIP">Range start IP.</param>
        /// <param name="endIP">Range end IP.</param>
        public void AddSecurityEntry(string id,bool enabled,string description,Service_enum service,IPSecurityAction_enum action,IPAddress startIP,IPAddress endIP)
        {
            if(id.Length == 0){
                throw new Exception("You must specify securityID");
            }

            using(WSqlCommand sqlCmd = new WSqlCommand(m_ConStr,"lspr_AddSecurityEntry")){
                sqlCmd.AddParameter("_id"          ,NpgsqlDbType.Varchar,id);
                sqlCmd.AddParameter("_enabled"     ,NpgsqlDbType.Boolean,enabled);
                sqlCmd.AddParameter("_description" ,NpgsqlDbType.Varchar,description);
                sqlCmd.AddParameter("_service"     ,NpgsqlDbType.Integer,(int)service);
                sqlCmd.AddParameter("_action"      ,NpgsqlDbType.Integer,(int)action);
                sqlCmd.AddParameter("_startIP"     ,NpgsqlDbType.Varchar,startIP.ToString());
                sqlCmd.AddParameter("_endIP"       ,NpgsqlDbType.Varchar,endIP.ToString());

                DataSet ds = sqlCmd.Execute();
            }
        }