internal void FillWith(MonadCommand command)
{
using (new OpenConnection(command.Connection))
{
this.CopyFrom(command.Execute());
}
}
public override void Apply(MrsPSHandler psHandler, MailboxSession mailboxSession)
{
using (MonadCommand command = psHandler.GetCommand(MrsCmdlet.SetConsumerMailbox))
{
int num = 1;
command.Parameters.AddWithValue("Identity", ConsumerMailboxIdParameter.Parse(mailboxSession.MailboxGuid.ToString()));
if (this.LastName != null)
{
command.Parameters.AddWithValue("LastName", this.LastName);
}
if (this.FirstName != null)
{
command.Parameters.AddWithValue("FirstName", this.FirstName);
}
if (this.BirthdayInt != 0)
{
command.Parameters.AddWithValue("Birthdate", this.BirthdayInt);
command.Parameters.AddWithValue("BirthdayPrecision", this.BirthdayPrecision);
}
if (command.Parameters.Count > num)
{
command.Execute();
}
}
}
public object[] ExecuteCommand(string command)
{
if (command == string.Empty)
{
throw new ArgumentNullException("command");
}
object[] result = null;
lock (this.monadConnection)
{
try
{
this.monadConnection.Open();
using (MonadCommand monadCommand = new MonadCommand(command, this.monadConnection))
{
monadCommand.CommandType = CommandType.Text;
result = monadCommand.Execute();
}
}
finally
{
if (this.monadConnection.State == ConnectionState.Open)
{
this.monadConnection.Close();
}
}
}
return(result);
}
private object GetVariable(string variableName, MonadConnection connection)
{
object result;
using (MonadCommand monadCommand = new MonadCommand("Get-Variable", connection))
{
monadCommand.Parameters.AddWithValue("Name", variableName);
object[] array = monadCommand.Execute();
result = ((array.Length > 0) ? (array[0] as PSVariable).Value : null);
}
return(result);
}
// Token: 0x0600139E RID: 5022 RVA: 0x0004526C File Offset: 0x0004346C
protected override ADRawEntry LoadExecutingUser(IIdentity identity, IList <PropertyDefinition> properties)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(70, 100, Strings.LoadingLogonUser(base.IdentityName), Strings.LoadingLogonUserErrorText(base.IdentityName));
ADRawEntry result;
using (new OpenConnection(connection))
{
MonadCommand monadCommand = new MonadCommand("Get-LogonUser", connection);
result = (ADRawEntry)monadCommand.Execute()[0];
}
return(result);
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
base.OnStart();
object value = row[base.FileDataParameterName];
try
{
using (new OpenConnection(FormatListFileSaveSaver.connection))
{
object[] value2 = null;
string variableName = "FormatEnumerationLimit";
int num = -1;
object variable = this.GetVariable(variableName, FormatListFileSaveSaver.connection);
if (variable != null)
{
int.TryParse(variable.ToString(), out num);
}
this.SetVariable(variableName, -1, FormatListFileSaveSaver.connection);
using (MonadCommand monadCommand = new MonadCommand("Format-List", FormatListFileSaveSaver.connection))
{
monadCommand.Parameters.Add(new MonadParameter("InputObject", value));
value2 = monadCommand.Execute();
}
using (MonadCommand monadCommand2 = new MonadCommand("Out-File", FormatListFileSaveSaver.connection))
{
monadCommand2.Parameters.Add(new MonadParameter("InputObject", value2));
monadCommand2.Parameters.Add(new MonadParameter("FilePath", row[base.FilePathParameterName]));
monadCommand2.Execute();
}
if (num != -1)
{
this.SetVariable(variableName, num, FormatListFileSaveSaver.connection);
}
base.OnComplete(true, null);
}
}
catch (CommandExecutionException exception)
{
base.OnComplete(false, exception);
}
catch (CmdletInvocationException exception2)
{
base.OnComplete(false, exception2);
}
catch (PipelineStoppedException exception3)
{
base.OnComplete(false, exception3);
}
}
// Token: 0x060013A0 RID: 5024 RVA: 0x000453C8 File Offset: 0x000435C8
protected override Result <ExchangeRole>[] LoadRoles(IConfigurationSession session, List <ADObjectId> roleIds)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] roles;
using (new OpenConnection(connection))
{
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(90, 100, Strings.LoadingRole(base.IdentityName), Strings.LoadingRoleErrorText(base.IdentityName));
MonadCommand monadCommand = new MonadCommand("Get-ManagementRoleForLogonUser", connection);
roles = monadCommand.Execute();
}
Result <ExchangeRole>[] array = new Result <ExchangeRole> [roleIds.Count];
for (int i = 0; i < roleIds.Count; i++)
{
array[i] = new Result <ExchangeRole>(this.FindRole(roles, roleIds[i]), null);
}
return(array);
}
// Token: 0x0600139F RID: 5023 RVA: 0x000452FC File Offset: 0x000434FC
protected override Result <ExchangeRoleAssignment>[] LoadRoleAssignments(IConfigurationSession session, ADRawEntry user, List <ADObjectId> existingRoleGroups)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] array;
using (new OpenConnection(connection))
{
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(75, 100, Strings.LoadingRoleAssignment(base.IdentityName), Strings.LoadingRoleAssignmentErrorText(base.IdentityName));
MonadCommand monadCommand = new MonadCommand("Get-ManagementRoleAssignmentForLogonUser", connection);
array = monadCommand.Execute();
}
Result <ExchangeRoleAssignment>[] array2 = new Result <ExchangeRoleAssignment> [array.Length];
for (int i = 0; i < array.Length; i++)
{
array2[i] = new Result <ExchangeRoleAssignment>((ExchangeRoleAssignment)((ExchangeRoleAssignmentPresentation)array[i]).DataObject, null);
}
return(array2);
}
// Token: 0x060013A1 RID: 5025 RVA: 0x00045498 File Offset: 0x00043698
protected override Result <ManagementScope>[] LoadScopes(IConfigurationSession session, ADObjectId[] scopeIds)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] scopes;
using (new OpenConnection(connection))
{
this.scopeReported = true;
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(80, 100, Strings.LoadingScope(base.IdentityName), Strings.LoadingScopeErrorText(base.IdentityName));
MonadCommand monadCommand = new MonadCommand("Get-ManagementScopeForLogonUser", connection);
scopes = monadCommand.Execute(scopeIds);
}
Result <ManagementScope>[] array = new Result <ManagementScope> [scopeIds.Length];
for (int i = 0; i < scopeIds.Length; i++)
{
array[i] = new Result <ManagementScope>(this.FindScope(scopes, scopeIds[i]), null);
}
return(array);
}
// Token: 0x060013A2 RID: 5026 RVA: 0x00045564 File Offset: 0x00043764
protected override ManagementScope[] LoadExclusiveScopes()
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] array;
using (new OpenConnection(connection))
{
if (!this.scopeReported)
{
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(80, 100, Strings.LoadingScope(base.IdentityName), Strings.LoadingScopeErrorText(base.IdentityName));
}
MonadCommand monadCommand = new MonadCommand("Get-ExclusiveManagementScopeForLogonUser", connection);
array = monadCommand.Execute();
}
ManagementScope[] array2 = new ManagementScope[array.Length];
for (int i = 0; i < array.Length; i++)
{
array2[i] = (array[i] as ManagementScope);
}
return(array2);
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
this.datetime = ((DateTime)ExDateTime.Now).ToString("yyyyMMdd-HHmmss");
try
{
string value = "LOGVERBOSE=1 TARGETDIR=\"" + this.InstallPath + "\"";
Dictionary <string, bool> dictionary = new Dictionary <string, bool>();
Dictionary <string, bool> dictionary2 = new Dictionary <string, bool>();
int num = 0;
for (int i = 0; i < this.LanguagePacksToInstall.Length; i++)
{
bool flag = Convert.ToBoolean(this.LPServerFlags[i]);
dictionary.Add(this.LanguagePacksToInstall[i], flag);
if (flag)
{
num++;
}
flag = Convert.ToBoolean(this.LPClientFlags[i]);
dictionary2.Add(this.LanguagePacksToInstall[i], flag);
if (flag)
{
num++;
}
}
int num2 = num * 2;
if (this.SourceIsBundle)
{
num2 += this.LanguagePacksToInstall.Length;
}
int num3 = 0;
foreach (string text in this.LanguagePacksToInstall)
{
int lcid = CultureInfo.GetCultureInfo(text).LCID;
string text2 = "";
if (this.SourceIsBundle)
{
TaskLogger.Log(Strings.ExtractingLang(text));
base.WriteProgress(this.Description, Strings.ExtractingLang(text), (int)((double)num3 * 100.0 / (double)num2 + 0.5));
DirectoryInfo directoryInfo = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(this.LangPackPath.PathName)));
string text3 = text + "\\";
EmbeddedCabWrapper.ExtractFiles(this.LangPackPath.PathName, directoryInfo.FullName, text3);
text2 = directoryInfo.FullName + '\\' + text3;
num3++;
}
else
{
text2 = Path.Combine(this.LangPackPath.PathName, text);
}
string text4 = Path.Combine(text2, "ClientLanguagePack.msi");
if (dictionary2[text] && File.Exists(text4))
{
TaskLogger.Log(Strings.UninstallOldMSIFor(text, "client"));
base.WriteProgress(this.Description, Strings.UninstallOldMSIFor(text, "client"), (int)((double)num3 * 100.0 / (double)num2 + 0.5));
using (MonadCommand monadCommand = new MonadCommand("Uninstall-MsiPackage", this.monadConnection))
{
string value2 = this.CreateMsilogPathname("Uninstall", "Client", text);
monadCommand.Parameters.AddWithValue("LogFile", value2);
Guid productCode = MsiUtility.GetProductCode(text4);
monadCommand.Parameters.AddWithValue("ProductCode", productCode);
monadCommand.Execute();
}
num3++;
TaskLogger.Log(Strings.InstallingMSIFor(text, "client"));
base.WriteProgress(this.Description, Strings.InstallingMSIFor(text, "client"), (int)((double)num3 * 100.0 / (double)num2 + 0.5));
using (MonadCommand monadCommand2 = new MonadCommand("Install-MsiPackage", this.monadConnection))
{
monadCommand2.Parameters.AddWithValue("PackagePath", text4);
string value3 = this.CreateMsilogPathname("Install", "Client", text);
monadCommand2.Parameters.AddWithValue("LogFile", value3);
monadCommand2.Parameters.AddWithValue("Features", new string[]
{
"AdminTools",
"Mailbox",
"ClientAccess",
"Gateway",
"Bridgehead",
"UnifiedMessaging",
"ClientLanguagePack"
});
monadCommand2.Parameters.AddWithValue("PropertyValues", value);
monadCommand2.Execute();
}
num3++;
}
text4 = Path.Combine(text2, "ServerLanguagePack.msi");
if (dictionary[text] && File.Exists(text4))
{
TaskLogger.Log(Strings.UninstallOldMSIFor(text, "server"));
base.WriteProgress(this.Description, Strings.UninstallOldMSIFor(text, "server"), (int)((double)num3 * 100.0 / (double)num2 + 0.5));
using (MonadCommand monadCommand3 = new MonadCommand("Uninstall-MsiPackage", this.monadConnection))
{
string value4 = this.CreateMsilogPathname("Uninstall", "Server", text);
monadCommand3.Parameters.AddWithValue("LogFile", value4);
Guid productCode2 = MsiUtility.GetProductCode(text4);
monadCommand3.Parameters.AddWithValue("ProductCode", productCode2);
monadCommand3.Execute();
}
num3++;
TaskLogger.Log(Strings.InstallingMSIFor(text, "server"));
base.WriteProgress(this.Description, Strings.InstallingMSIFor(text, "server"), (int)((double)num3 * 100.0 / (double)num2 + 0.5));
using (MonadCommand monadCommand4 = new MonadCommand("Install-MsiPackage", this.monadConnection))
{
monadCommand4.Parameters.AddWithValue("PackagePath", text4);
string value5 = this.CreateMsilogPathname("Install", "Server", text);
monadCommand4.Parameters.AddWithValue("LogFile", value5);
monadCommand4.Parameters.AddWithValue("Features", new string[]
{
"AdminTools",
"Mailbox",
"ClientAccess",
"Gateway",
"Bridgehead",
"UnifiedMessaging",
"ServerLanguagePack"
});
monadCommand4.Parameters.AddWithValue("PropertyValues", value);
monadCommand4.Execute();
}
num3++;
}
if (this.SourceIsBundle)
{
try
{
Directory.Delete(text2, true);
}
catch (IOException e)
{
TaskLogger.LogError(e);
}
}
}
}
finally
{
base.WriteProgress(this.Description, Strings.ProgressStatusCompleted, 100);
TaskLogger.LogExit();
}
}
private static void LoadBaseUrlViaCmdlet(HelpProvider.HelpAppName appName, RunspaceServerSettingsPresentationObject runspaceServerSettings, MonadConnectionInfo monadConnectionInfo)
{
if (appName != HelpProvider.HelpAppName.Toolbox)
{
if (appName != HelpProvider.HelpAppName.Eap)
{
throw new InvalidOperationException("appName is not a valid HelpAppName enum. Check caller of Initialize how we get this value.");
}
}
try
{
ExchangeAssistance exchangeAssistance = null;
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), runspaceServerSettings, monadConnectionInfo);
using (new OpenConnection(connection))
{
using (MonadCommand monadCommand = new MonadCommand("Get-ExchangeAssistanceConfig", connection))
{
object[] array = monadCommand.Execute();
if (array != null && array.Length != 0)
{
exchangeAssistance = (array[0] as ExchangeAssistance);
}
}
}
if (exchangeAssistance != null)
{
if (exchangeAssistance.ManagementConsoleHelpURL != null)
{
HelpProvider.baseUrl = Utilities.NormalizeUrl(exchangeAssistance.ManagementConsoleHelpURL);
}
if (exchangeAssistance.ManagementConsoleFeedbackEnabled)
{
HelpProvider.managementConsoleFeedbackUrl = exchangeAssistance.ManagementConsoleFeedbackURL;
}
else
{
HelpProvider.managementConsoleFeedbackUrl = null;
}
if (exchangeAssistance.PrivacyLinkDisplayEnabled)
{
HelpProvider.privacyStatementUrl = exchangeAssistance.PrivacyStatementURL;
}
else
{
HelpProvider.privacyStatementUrl = null;
}
if (exchangeAssistance.WindowsLiveAccountURLEnabled)
{
HelpProvider.windowsLiveAccountUrl = exchangeAssistance.WindowsLiveAccountPageURL;
}
else
{
HelpProvider.windowsLiveAccountUrl = null;
}
if (exchangeAssistance.CommunityLinkDisplayEnabled)
{
HelpProvider.communityUrl = exchangeAssistance.CommunityURL;
}
else
{
HelpProvider.communityUrl = null;
}
}
}
catch (CommandExecutionException ex)
{
ExTraceGlobals.CoreTracer.TraceDebug <string>(0L, "CommandExecution Exception in LoadBaseURL: {0}", ex.Message);
}
catch (CmdletInvocationException ex2)
{
ExTraceGlobals.CoreTracer.TraceDebug <string>(0L, "CmdletInvocationException Exception in LoadBaseURL: {0}", ex2.Message);
}
catch (PipelineStoppedException ex3)
{
ExTraceGlobals.CoreTracer.TraceDebug <string>(0L, "PipelineStopped Exception in LoadBaseURL: {0}", ex3.Message);
}
HelpProvider.callingAppName = appName;
}
