public void Restore(string fileName, RestoreFlags_enum restoreFlags)
{
using (FileStream fileStream = File.OpenRead(fileName))
{
this.Restore(fileStream, restoreFlags);
}
}
private void m_pRestore_Click(object sender, EventArgs e)
{
RestoreFlags_enum restoreFlags_enum = (RestoreFlags_enum)0;
if (this.m_pRestoreFlagsAdd.Checked)
{
restoreFlags_enum |= RestoreFlags_enum.Add;
}
if (this.m_pRestoreFlagsReplace.Checked)
{
restoreFlags_enum |= RestoreFlags_enum.Replace;
}
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "DataSmart Mail Server backup (*.lsmbck)|*.lsmbck";
if (openFileDialog.ShowDialog(this) == DialogResult.OK)
{
this.m_pVirtualServer.Restore(openFileDialog.FileName, restoreFlags_enum);
}
}
private void m_pRestore_Click(object sender, EventArgs e)
{
RestoreFlags_enum restoreFlags = 0;
if (m_pRestoreFlagsAdd.Checked)
{
restoreFlags |= RestoreFlags_enum.Add;
}
if (m_pRestoreFlagsReplace.Checked)
{
restoreFlags |= RestoreFlags_enum.Replace;
}
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = "LS Mail Server backup (*.lsmbck)|*.lsmbck";
if (dlg.ShowDialog(this) == DialogResult.OK)
{
m_pVirtualServer.Restore(dlg.FileName, restoreFlags);
}
}
/// <summary>
/// Restores all virtual server settings from the specified stream.
/// </summary>
/// <param name="stream">Stream what conatins backup.</param>
/// <param name="restoreFlags">Specifies restore options.</param>
public void Restore(Stream stream,RestoreFlags_enum restoreFlags)
{
DataSet ds = new DataSet();
ds.ReadXml(stream);
#region Settings
/* NOTE: Settings need special handling, we can't comapre settings, so just always overwrite it.
*/
if(ds.Tables.Contains("Settings")){
this.SystemSettings.LoadSettings(ds);
this.SystemSettings.Commit();
}
#endregion
#region Domains
/* NOTE: Domains must act differenly compared other object, because deleting domain looses mailboxes.
We need to update domain, if ResoreFlags_enum.Replace, we can't delete domain !!!
*/
if(ds.Tables.Contains("Domains")){
foreach(DataRow dr in ds.Tables["Domains"].Rows){
// Update exisiting domain, if ResoreFlags_enum.Replace
if(this.Domains.Contains(dr["DomainName"].ToString())){
if((restoreFlags & RestoreFlags_enum.Replace) != 0){
// TODO:
}
}
// Add domain list, if ResoreFlags_enum.Add
else if((restoreFlags & RestoreFlags_enum.Add) != 0){
Domain domain = this.Domains.Add(
dr["DomainName"].ToString(),
dr["Description"].ToString()
);
}
}
}
#endregion
#region Users
/* NOTE: Users must act differenly compared other object, because deleting user looses mailbox.
We need to update user, if ResoreFlags_enum.Replace, we can't delete user !!!
*/
if(ds.Tables.Contains("Users")){
foreach(DataRow dr in ds.Tables["Users"].Rows){
User user = null;
bool userChanged = false;
// Update exisiting domain, if ResoreFlags_enum.Replace
if(this.Users.Contains(dr["UserName"].ToString())){
if((restoreFlags & RestoreFlags_enum.Replace) != 0){
user = this.Users.GetUserByName(dr["UserName"].ToString());
user.UserName = dr["UserName"].ToString();
user.FullName = dr["FullName"].ToString();
user.Password = dr["Password"].ToString();
user.Description = dr["Description"].ToString();
user.MaximumMailboxSize = ConvertEx.ToInt32(dr["Mailbox_Size"]);
user.Enabled = ConvertEx.ToBoolean(dr["Enabled"]);
user.Permissions = (UserPermissions_enum)ConvertEx.ToInt32(dr["Permissions"]);
user.Commit();
// Delete user email addresses
foreach(string emailAddress in user.EmailAddresses.ToArray()){
user.EmailAddresses.Remove(emailAddress);
}
// Delete user remote servers
foreach(UserRemoteServer server in user.RemoteServers.ToArray()){
user.RemoteServers.Remove(server);
}
// Delete user message rules
foreach(UserMessageRule rule in user.MessageRules.ToArray()){
user.MessageRules.Remove(rule);
}
userChanged = true;
}
}
// Add domain list, if ResoreFlags_enum.Add
else if((restoreFlags & RestoreFlags_enum.Add) != 0){
user = this.Users.Add(
dr["UserName"].ToString(),
dr["FullName"].ToString(),
dr["Password"].ToString(),
dr["Description"].ToString(),
ConvertEx.ToInt32(dr["Mailbox_Size"]),
ConvertEx.ToBoolean(dr["Enabled"]),
(UserPermissions_enum)ConvertEx.ToInt32(dr["Permissions"])
);
userChanged = true;
}
if(userChanged){
// Add user remote servers
if(ds.Tables.Contains("User_EmailAddresses")){
DataView dv = new DataView(ds.Tables["User_EmailAddresses"]);
dv.RowFilter = "UserID='" + dr["UserID"].ToString() + "'";
foreach(DataRowView drV in dv){
user.EmailAddresses.Add(
drV["EmailAddress"].ToString()
);
}
}
// Add user remote servers
if(ds.Tables.Contains("User_RemoteServers")){
DataView dv = new DataView(ds.Tables["User_RemoteServers"]);
dv.RowFilter = "UserID='" + dr["UserID"].ToString() + "'";
foreach(DataRowView drV in dv){
user.RemoteServers.Add(
drV["Description"].ToString(),
drV["RemoteServer"].ToString(),
ConvertEx.ToInt32(drV["RemotePort"]),
ConvertEx.ToBoolean(drV["UseSSL"]),
drV["RemoteUserName"].ToString(),
drV["RemotePassword"].ToString(),
ConvertEx.ToBoolean(drV["Enabled"])
);
}
}
// Add user message rules
if(ds.Tables.Contains("User_MessageRules")){
DataView dv = new DataView(ds.Tables["User_MessageRules"]);
dv.RowFilter = "UserID='" + dr["UserID"].ToString() + "'";
foreach(DataRowView drV in dv){
UserMessageRule rule = user.MessageRules.Add(
ConvertEx.ToBoolean(drV["Enabled"]),
drV["Description"].ToString(),
drV["MatchExpression"].ToString(),
(GlobalMessageRule_CheckNextRule_enum)ConvertEx.ToInt32(drV["CheckNextRuleIf"])
);
// Add rule actions
if(ds.Tables.Contains("User_MessageRuleActions")){
DataView dvRuleActions = new DataView(ds.Tables["User_MessageRuleActions"]);
dvRuleActions.RowFilter = "UserID='" + dr["UserID"].ToString() + "' AND RuleID='" + drV["RuleID"].ToString() + "'";
foreach(DataRowView drvAction in dvRuleActions){
rule.Actions.Add(
drvAction["ActionID"].ToString(),
drvAction["Description"].ToString(),
(UserMessageRuleAction_enum)Convert.ToInt32(drvAction["ActionType"]),
Convert.FromBase64String(drvAction["ActionData"].ToString()),
true
);
}
}
}
}
}
}
}
#endregion
#region Groups
if(ds.Tables.Contains("Groups")){
foreach(DataRow dr in ds.Tables["Groups"].Rows){
// Delete exisiting group, if ResoreFlags_enum.Replace
bool replaceAdd = false;
if(this.Groups.Contains(dr["GroupName"].ToString()) && (restoreFlags & RestoreFlags_enum.Replace) != 0){
this.Groups.Remove(this.Groups.GetGroupByName(dr["GroupName"].ToString()));
replaceAdd = true;
}
// Add group, if ResoreFlags_enum.Add or Replace group add
if(!this.Groups.Contains(dr["GroupName"].ToString()) && (replaceAdd || (restoreFlags & RestoreFlags_enum.Add) != 0)){
Group group = this.Groups.Add(
dr["GroupName"].ToString(),
dr["Description"].ToString(),
ConvertEx.ToBoolean(dr["Enabled"])
);
// Add group members
if(ds.Tables.Contains("Group_Members")){
DataView dv = new DataView(ds.Tables["Group_Members"]);
dv.RowFilter = "GroupID='" + dr["GroupID"].ToString() + "'";
foreach(DataRowView drV in dv){
group.Members.Add(drV["UserOrGroup"].ToString());
}
}
}
}
}
#endregion
#region Mailing lists
if(ds.Tables.Contains("MailingLists")){
foreach(DataRow dr in ds.Tables["MailingLists"].Rows){
// Delete exisiting mailing list, if ResoreFlags_enum.Replace
bool replaceAdd = false;
if(this.MailingLists.Contains(dr["MailingListName"].ToString()) && (restoreFlags & RestoreFlags_enum.Replace) != 0){
this.MailingLists.Remove(this.MailingLists.GetMailingListByName(dr["MailingListName"].ToString()));
replaceAdd = true;
}
// Add mailing list, if ResoreFlags_enum.Add or Replace mailing list add
if(!this.MailingLists.Contains(dr["MailingListName"].ToString()) && (replaceAdd || (restoreFlags & RestoreFlags_enum.Add) != 0)){
MailingList list = this.MailingLists.Add(
dr["MailingListName"].ToString(),
dr["Description"].ToString(),
ConvertEx.ToBoolean(dr["Enabled"])
);
// Add mailing list members
if(ds.Tables.Contains("MailingList_Members")){
DataView dv = new DataView(ds.Tables["MailingList_Members"]);
dv.RowFilter = "MailingListID='" + dr["MailingListID"].ToString() + "'";
foreach(DataRowView drV in dv){
list.Members.Add(drV["Address"].ToString());
}
}
// Add mailing list ACL
if(ds.Tables.Contains("MailingList_ACL")){
DataView dv = new DataView(ds.Tables["MailingList_ACL"]);
dv.RowFilter = "MailingListID='" + dr["MailingListID"].ToString() + "'";
foreach(DataRowView drV in dv){
list.ACL.Add(drV["UserOrGroup"].ToString());
}
}
}
}
}
#endregion
#region Routes
if(ds.Tables.Contains("Routing")){
foreach(DataRow dr in ds.Tables["Routing"].Rows){
// Delete exisiting route, if ResoreFlags_enum.Replace
bool replaceAdd = false;
if(this.Routes.ContainsPattern(dr["Pattern"].ToString()) && (restoreFlags & RestoreFlags_enum.Replace) != 0){
this.Routes.Remove(this.Routes.GetRouteByPattern(dr["Pattern"].ToString()));
replaceAdd = true;
}
// Add route, if ResoreFlags_enum.Add or Replace route add
if(!this.Routes.ContainsPattern(dr["Pattern"].ToString()) && (replaceAdd || (restoreFlags & RestoreFlags_enum.Add) != 0)){
RouteAction_enum actionType = (RouteAction_enum)Convert.ToInt32(dr["Action"]);
RouteActionBase action = null;
if(actionType == RouteAction_enum.RouteToEmail){
action = new RouteAction_RouteToEmail(Convert.FromBase64String(dr["ActionData"].ToString()));
}
else if(actionType == RouteAction_enum.RouteToHost){
action = new RouteAction_RouteToHost(Convert.FromBase64String(dr["ActionData"].ToString()));
}
else if(actionType == RouteAction_enum.RouteToMailbox){
action = new RouteAction_RouteToMailbox(Convert.FromBase64String(dr["ActionData"].ToString()));
}
Route route = this.Routes.Add(
dr["Description"].ToString(),
dr["Pattern"].ToString(),
ConvertEx.ToBoolean(dr["Enabled"]),
action
);
}
}
}
#endregion
#region Global message rules
// Add user message rules
if(ds.Tables.Contains("GlobalMessageRules")){
// Delete exisiting global message rules, if ResoreFlags_enum.Replace
if((restoreFlags & RestoreFlags_enum.Replace) != 0){
foreach(GlobalMessageRule rule in this.GlobalMessageRules){
this.GlobalMessageRules.Remove(rule);
}
}
DataView dv = new DataView(ds.Tables["GlobalMessageRules"]);
foreach(DataRowView drV in dv){
GlobalMessageRule rule = this.GlobalMessageRules.Add(
ConvertEx.ToBoolean(drV["Enabled"]),
drV["Description"].ToString(),
drV["MatchExpression"].ToString(),
(GlobalMessageRule_CheckNextRule_enum)ConvertEx.ToInt32(drV["CheckNextRuleIf"])
);
// Add rule actions
if(ds.Tables.Contains("GlobalMessageRuleActions")){
DataView dvRuleActions = new DataView(ds.Tables["GlobalMessageRuleActions"]);
dvRuleActions.RowFilter = "RuleID='" + drV["RuleID"].ToString() + "'";
foreach(DataRowView drvAction in dvRuleActions){
rule.Actions.Add(
drvAction["ActionID"].ToString(),
drvAction["Description"].ToString(),
(GlobalMessageRuleAction_enum)Convert.ToInt32(drvAction["ActionType"]),
Convert.FromBase64String(drvAction["ActionData"].ToString()),
true
);
}
}
}
}
#endregion
#region IP Security
/* NOTE: IP security need special handling, we can't comapre values, so just always overwrite it.
*/
if(ds.Tables.Contains("IP_Security")){
// Delete filters
foreach(IPSecurity entry in this.IpSecurity.ToArray()){
this.IpSecurity.Remove(entry);
}
foreach(DataRow dr in ds.Tables["IP_Security"].Rows){
this.IpSecurity.Add(
ConvertEx.ToBoolean(dr["Enabled"]),
dr["Description"].ToString(),
(Service_enum)ConvertEx.ToInt32(dr["Service"]),
(IPSecurityAction_enum)ConvertEx.ToInt32(dr["Action"]),
IPAddress.Parse(dr["StartIP"].ToString()),
IPAddress.Parse(dr["EndIP"].ToString())
);
}
}
#endregion
#region Filters
/* NOTE: Filters need special handling, we can't comapre values, so just always overwrite it.
*/
if(ds.Tables.Contains("Filters")){
// Delete filters
foreach(Filter filter in this.Filters.ToArray()){
this.Filters.Remove(filter);
}
foreach(DataRow dr in ds.Tables["Filters"].Rows){
this.Filters.Add(
ConvertEx.ToBoolean(dr["Enabled"]),
dr["Description"].ToString(),
dr["Assembly"].ToString(),
dr["ClassName"].ToString()
);
}
}
#endregion
#region Users Default Folders
if(ds.Tables.Contains("UsersDefaultFolders")){
foreach(DataRow dr in ds.Tables["UsersDefaultFolders"].Rows){
// Delete exisiting folder and add new, if ResoreFlags_enum.Replace
if(this.UsersDefaultFolders.Contains(dr["FolderName"].ToString())){
if((restoreFlags & RestoreFlags_enum.Replace) != 0){
this.UsersDefaultFolders.Remove(this.UsersDefaultFolders.GetFolderByName(dr["FolderName"].ToString()));
UsersDefaultFolder folder = this.UsersDefaultFolders.Add(
dr["FolderName"].ToString(),
ConvertEx.ToBoolean(dr["Permanent"])
);
}
}
// Add domain list, if ResoreFlags_enum.Add
else if((restoreFlags & RestoreFlags_enum.Add) != 0){
UsersDefaultFolder folder = this.UsersDefaultFolders.Add(
dr["FolderName"].ToString(),
ConvertEx.ToBoolean(dr["Permanent"])
);
}
}
}
#endregion
}
/// <summary>
/// Restores all virtual server settings from the specified file.
/// </summary>
/// <param name="fileName">File what conatins backup.</param>
/// <param name="restoreFlags">Specifies restore options.</param>
public void Restore(string fileName,RestoreFlags_enum restoreFlags)
{
using(FileStream fs = File.OpenRead(fileName)){
Restore(fs,restoreFlags);
}
}
public void Restore(Stream stream, RestoreFlags_enum restoreFlags)
{
DataSet dataSet = new DataSet();
dataSet.ReadXml(stream);
if (dataSet.Tables.Contains("Settings"))
{
this.SystemSettings.LoadSettings(dataSet);
this.SystemSettings.Commit();
}
if (dataSet.Tables.Contains("Domains"))
{
foreach (DataRow dataRow in dataSet.Tables["Domains"].Rows)
{
if (this.Domains.Contains(dataRow["DomainName"].ToString()))
{
if ((restoreFlags & RestoreFlags_enum.Replace) != (RestoreFlags_enum)0)
{
}
}
else if ((restoreFlags & RestoreFlags_enum.Add) != (RestoreFlags_enum)0)
{
this.Domains.Add(dataRow["DomainName"].ToString(), dataRow["Description"].ToString());
}
}
}
if (dataSet.Tables.Contains("Users"))
{
foreach (DataRow dataRow2 in dataSet.Tables["Users"].Rows)
{
User user = null;
bool flag = false;
if (this.Users.Contains(dataRow2["UserName"].ToString()))
{
if ((restoreFlags & RestoreFlags_enum.Replace) != (RestoreFlags_enum)0)
{
user = this.Users.GetUserByName(dataRow2["UserName"].ToString());
user.UserName = dataRow2["UserName"].ToString();
user.FullName = dataRow2["FullName"].ToString();
user.Password = dataRow2["Password"].ToString();
user.Description = dataRow2["Description"].ToString();
user.MaximumMailboxSize = ConvertEx.ToInt32(dataRow2["Mailbox_Size"]);
user.Enabled = ConvertEx.ToBoolean(dataRow2["Enabled"]);
user.Permissions = (UserPermissions)ConvertEx.ToInt32(dataRow2["Permissions"]);
user.Commit();
string[] array = user.EmailAddresses.ToArray();
for (int i = 0; i < array.Length; i++)
{
string emailAddress = array[i];
user.EmailAddresses.Remove(emailAddress);
}
UserRemoteServer[] array2 = user.RemoteServers.ToArray();
for (int j = 0; j < array2.Length; j++)
{
UserRemoteServer remoteServer = array2[j];
user.RemoteServers.Remove(remoteServer);
}
UserMessageRule[] array3 = user.MessageRules.ToArray();
for (int k = 0; k < array3.Length; k++)
{
UserMessageRule rule = array3[k];
user.MessageRules.Remove(rule);
}
flag = true;
}
}
else if ((restoreFlags & RestoreFlags_enum.Add) != (RestoreFlags_enum)0)
{
user = this.Users.Add(dataRow2["UserName"].ToString(), dataRow2["FullName"].ToString(), dataRow2["Password"].ToString(), dataRow2["Description"].ToString(), ConvertEx.ToInt32(dataRow2["Mailbox_Size"]), ConvertEx.ToBoolean(dataRow2["Enabled"]), (UserPermissions)ConvertEx.ToInt32(dataRow2["Permissions"]));
flag = true;
}
if (flag)
{
if (dataSet.Tables.Contains("User_EmailAddresses"))
{
foreach (DataRowView dataRowView in new DataView(dataSet.Tables["User_EmailAddresses"])
{
RowFilter = "UserID='" + dataRow2["UserID"].ToString() + "'"
})
{
user.EmailAddresses.Add(dataRowView["EmailAddress"].ToString());
}
}
if (dataSet.Tables.Contains("User_RemoteServers"))
{
foreach (DataRowView dataRowView2 in new DataView(dataSet.Tables["User_RemoteServers"])
{
RowFilter = "UserID='" + dataRow2["UserID"].ToString() + "'"
})
{
user.RemoteServers.Add(dataRowView2["Description"].ToString(), dataRowView2["RemoteServer"].ToString(), ConvertEx.ToInt32(dataRowView2["RemotePort"]), ConvertEx.ToBoolean(dataRowView2["UseSSL"]), dataRowView2["RemoteUserName"].ToString(), dataRowView2["RemotePassword"].ToString(), ConvertEx.ToBoolean(dataRowView2["Enabled"]));
}
}
if (dataSet.Tables.Contains("User_MessageRules"))
{
foreach (DataRowView dataRowView3 in new DataView(dataSet.Tables["User_MessageRules"])
{
RowFilter = "UserID='" + dataRow2["UserID"].ToString() + "'"
})
{
UserMessageRule userMessageRule = user.MessageRules.Add(ConvertEx.ToBoolean(dataRowView3["Enabled"]), dataRowView3["Description"].ToString(), dataRowView3["MatchExpression"].ToString(), (GlobalMessageRule_CheckNextRule)ConvertEx.ToInt32(dataRowView3["CheckNextRuleIf"]));
if (dataSet.Tables.Contains("User_MessageRuleActions"))
{
foreach (DataRowView dataRowView4 in new DataView(dataSet.Tables["User_MessageRuleActions"])
{
RowFilter = string.Concat(new string[]
{
"UserID='",
dataRow2["UserID"].ToString(),
"' AND RuleID='",
dataRowView3["RuleID"].ToString(),
"'"
})
})
{
userMessageRule.Actions.Add(dataRowView4["ActionID"].ToString(), dataRowView4["Description"].ToString(), (UserMessageRuleActionType)Convert.ToInt32(dataRowView4["ActionType"]), Convert.FromBase64String(dataRowView4["ActionData"].ToString()), true);
}
}
}
}
}
}
}
if (dataSet.Tables.Contains("Groups"))
{
foreach (DataRow dataRow3 in dataSet.Tables["Groups"].Rows)
{
bool flag2 = false;
if (this.Groups.Contains(dataRow3["GroupName"].ToString()) && (restoreFlags & RestoreFlags_enum.Replace) != (RestoreFlags_enum)0)
{
this.Groups.Remove(this.Groups.GetGroupByName(dataRow3["GroupName"].ToString()));
flag2 = true;
}
if (!this.Groups.Contains(dataRow3["GroupName"].ToString()) && (flag2 || (restoreFlags & RestoreFlags_enum.Add) != (RestoreFlags_enum)0))
{
Group group = this.Groups.Add(dataRow3["GroupName"].ToString(), dataRow3["Description"].ToString(), ConvertEx.ToBoolean(dataRow3["Enabled"]));
if (dataSet.Tables.Contains("Group_Members"))
{
foreach (DataRowView dataRowView5 in new DataView(dataSet.Tables["Group_Members"])
{
RowFilter = "GroupID='" + dataRow3["GroupID"].ToString() + "'"
})
{
group.Members.Add(dataRowView5["UserOrGroup"].ToString());
}
}
}
}
}
if (dataSet.Tables.Contains("MailingLists"))
{
foreach (DataRow dataRow4 in dataSet.Tables["MailingLists"].Rows)
{
bool flag3 = false;
if (this.MailingLists.Contains(dataRow4["MailingListName"].ToString()) && (restoreFlags & RestoreFlags_enum.Replace) != (RestoreFlags_enum)0)
{
this.MailingLists.Remove(this.MailingLists.GetMailingListByName(dataRow4["MailingListName"].ToString()));
flag3 = true;
}
if (!this.MailingLists.Contains(dataRow4["MailingListName"].ToString()) && (flag3 || (restoreFlags & RestoreFlags_enum.Add) != (RestoreFlags_enum)0))
{
MailingList mailingList = this.MailingLists.Add(dataRow4["MailingListName"].ToString(), dataRow4["Description"].ToString(), ConvertEx.ToBoolean(dataRow4["Enabled"]));
if (dataSet.Tables.Contains("MailingList_Members"))
{
foreach (DataRowView dataRowView6 in new DataView(dataSet.Tables["MailingList_Members"])
{
RowFilter = "MailingListID='" + dataRow4["MailingListID"].ToString() + "'"
})
{
mailingList.Members.Add(dataRowView6["Address"].ToString());
}
}
if (dataSet.Tables.Contains("MailingList_ACL"))
{
foreach (DataRowView dataRowView7 in new DataView(dataSet.Tables["MailingList_ACL"])
{
RowFilter = "MailingListID='" + dataRow4["MailingListID"].ToString() + "'"
})
{
mailingList.ACL.Add(dataRowView7["UserOrGroup"].ToString());
}
}
}
}
}
if (dataSet.Tables.Contains("Routing"))
{
foreach (DataRow dataRow5 in dataSet.Tables["Routing"].Rows)
{
bool flag4 = false;
if (this.Routes.ContainsPattern(dataRow5["Pattern"].ToString()) && (restoreFlags & RestoreFlags_enum.Replace) != (RestoreFlags_enum)0)
{
this.Routes.Remove(this.Routes.GetRouteByPattern(dataRow5["Pattern"].ToString()));
flag4 = true;
}
if (!this.Routes.ContainsPattern(dataRow5["Pattern"].ToString()) && (flag4 || (restoreFlags & RestoreFlags_enum.Add) != (RestoreFlags_enum)0))
{
RouteAction routeAction_enum = (RouteAction)Convert.ToInt32(dataRow5["Action"]);
RouteActionBase action = null;
if (routeAction_enum == RouteAction.RouteToEmail)
{
action = new RouteAction_RouteToEmail(Convert.FromBase64String(dataRow5["ActionData"].ToString()));
}
else if (routeAction_enum == RouteAction.RouteToHost)
{
action = new RouteAction_RouteToHost(Convert.FromBase64String(dataRow5["ActionData"].ToString()));
}
else if (routeAction_enum == RouteAction.RouteToMailbox)
{
action = new RouteAction_RouteToMailbox(Convert.FromBase64String(dataRow5["ActionData"].ToString()));
}
this.Routes.Add(dataRow5["Description"].ToString(), dataRow5["Pattern"].ToString(), ConvertEx.ToBoolean(dataRow5["Enabled"]), action);
}
}
}
if (dataSet.Tables.Contains("GlobalMessageRules"))
{
IEnumerator enumerator;
if ((restoreFlags & RestoreFlags_enum.Replace) != (RestoreFlags_enum)0)
{
enumerator = this.GlobalMessageRules.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
GlobalMessageRule rule2 = (GlobalMessageRule)enumerator.Current;
this.GlobalMessageRules.Remove(rule2);
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
DataView dataView = new DataView(dataSet.Tables["GlobalMessageRules"]);
enumerator = dataView.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
DataRowView dataRowView8 = (DataRowView)enumerator.Current;
GlobalMessageRule globalMessageRule = this.GlobalMessageRules.Add(ConvertEx.ToBoolean(dataRowView8["Enabled"]), dataRowView8["Description"].ToString(), dataRowView8["MatchExpression"].ToString(), (GlobalMessageRule_CheckNextRule)ConvertEx.ToInt32(dataRowView8["CheckNextRuleIf"]));
if (dataSet.Tables.Contains("GlobalMessageRuleActions"))
{
foreach (DataRowView dataRowView9 in new DataView(dataSet.Tables["GlobalMessageRuleActions"])
{
RowFilter = "RuleID='" + dataRowView8["RuleID"].ToString() + "'"
})
{
globalMessageRule.Actions.Add(dataRowView9["ActionID"].ToString(), dataRowView9["Description"].ToString(), (GlobalMessageRuleActionType)Convert.ToInt32(dataRowView9["ActionType"]), Convert.FromBase64String(dataRowView9["ActionData"].ToString()), true);
}
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
if (dataSet.Tables.Contains("IP_Security"))
{
IPSecurity[] array4 = this.IpSecurity.ToArray();
for (int i = 0; i < array4.Length; i++)
{
IPSecurity entry = array4[i];
this.IpSecurity.Remove(entry);
}
foreach (DataRow dataRow6 in dataSet.Tables["IP_Security"].Rows)
{
this.IpSecurity.Add(ConvertEx.ToBoolean(dataRow6["Enabled"]), dataRow6["Description"].ToString(), (ServiceKind)ConvertEx.ToInt32(dataRow6["Service"]), (IPSecurityAction)ConvertEx.ToInt32(dataRow6["Action"]), IPAddress.Parse(dataRow6["StartIP"].ToString()), IPAddress.Parse(dataRow6["EndIP"].ToString()));
}
}
if (dataSet.Tables.Contains("Filters"))
{
Filter[] array5 = this.Filters.ToArray();
for (int i = 0; i < array5.Length; i++)
{
Filter filter = array5[i];
this.Filters.Remove(filter);
}
foreach (DataRow dataRow7 in dataSet.Tables["Filters"].Rows)
{
this.Filters.Add(ConvertEx.ToBoolean(dataRow7["Enabled"]), dataRow7["Description"].ToString(), dataRow7["Assembly"].ToString(), dataRow7["ClassName"].ToString());
}
}
if (dataSet.Tables.Contains("UsersDefaultFolders"))
{
foreach (DataRow dataRow8 in dataSet.Tables["UsersDefaultFolders"].Rows)
{
if (this.UsersDefaultFolders.Contains(dataRow8["FolderName"].ToString()))
{
if ((restoreFlags & RestoreFlags_enum.Replace) != (RestoreFlags_enum)0)
{
this.UsersDefaultFolders.Remove(this.UsersDefaultFolders.GetFolderByName(dataRow8["FolderName"].ToString()));
this.UsersDefaultFolders.Add(dataRow8["FolderName"].ToString(), ConvertEx.ToBoolean(dataRow8["Permanent"]));
}
}
else if ((restoreFlags & RestoreFlags_enum.Add) != (RestoreFlags_enum)0)
{
this.UsersDefaultFolders.Add(dataRow8["FolderName"].ToString(), ConvertEx.ToBoolean(dataRow8["Permanent"]));
}
}
}
}
