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 IEnumerable <T> RunOneCommand <T>(string command, Dictionary <string, object> parameters, bool ignoreNotFoundErrors)
{
Collection <PSObject> collection = this.RunCommand(command, parameters, ignoreNotFoundErrors);
List <T> list = new List <T>();
if (collection.Count > 0)
{
if (collection[0] != null && collection[0].BaseObject != null && collection[0].BaseObject is PSCustomObject && MonadCommand.CanDeserialize(collection[0]))
{
using (IEnumerator <PSObject> enumerator = collection.GetEnumerator())
{
while (enumerator.MoveNext())
{
PSObject psobject = enumerator.Current;
if (psobject != null)
{
list.Add((T)((object)MonadCommand.Deserialize(psobject)));
}
}
return(list);
}
}
throw new InvalidOperationException(Strings.HybridInfoPurePSObjectsNotSupported);
}
return(list);
}
internal static object ConvertPSObjectToOriginalType(PSObject psObject, int remoteServerVersion, Task.TaskVerboseLoggingDelegate writeVerbose)
{
if (psObject == null)
{
throw new ArgumentNullException("psObject");
}
Type type = MonadCommand.ResolveType(psObject);
if (remoteServerVersion >= Server.E15MinVersion)
{
if (psObject.Members["SerializationData"] == null || psObject.Members["SerializationData"].Value == null)
{
if (writeVerbose != null)
{
writeVerbose(Strings.VerboseSerializationDataNotExist);
}
}
else
{
try
{
return(ProxyHelper.TypeConvertor.ConvertFrom(psObject, type, null, true));
}
catch (Exception ex)
{
if (writeVerbose != null)
{
writeVerbose(Strings.VerboseFailedToDeserializePSObject(ex.Message));
}
}
}
}
return(MockObjectInformation.TranslateToMockObject(type, psObject));
}
private static IList <string> BuildParameterStrings(DataRow row, IList <ParameterProfile> paramInfos)
{
List <string> list = new List <string>();
foreach (ParameterProfile parameterProfile in paramInfos)
{
if (parameterProfile.IsRunnable(row))
{
switch (parameterProfile.ParameterType)
{
case ParameterType.Switched:
list.Add(string.Format("-{0} ", parameterProfile.Name));
break;
case ParameterType.Column:
case ParameterType.ModifiedColumn:
{
string arg = MonadCommand.FormatParameterValue(MonadSaveTask.ConvertToParameterValue(row, parameterProfile));
list.Add(string.Format("-{0} {1} ", parameterProfile.Name, arg));
break;
}
default:
list.Add(string.Empty);
break;
}
}
else
{
list.Add(string.Empty);
}
}
return(list);
}
public static void StartExecution(object sender, StartExecutionEventArgs e)
{
MonadCommand monadCommand = sender as MonadCommand;
StringBuilder stringBuilder = new StringBuilder();
if (e.Pipeline != null)
{
int num = 0;
foreach (object value in e.Pipeline)
{
if (num != 0)
{
stringBuilder.Append(",");
}
num++;
stringBuilder.Append(MonadCommand.FormatParameterValue(value));
}
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" | ");
}
}
stringBuilder.Append(monadCommand.ToString());
CommandLoggingDialog.LogStart(e.Guid, (DateTime)ExDateTime.Now, stringBuilder.ToString());
}
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 void SetVariable(string variableName, object value, MonadConnection connection)
{
using (MonadCommand monadCommand = new MonadCommand("Set-Variable", connection))
{
monadCommand.Parameters.AddWithValue("Name", variableName);
monadCommand.Parameters.AddWithValue("Value", value);
monadCommand.ExecuteNonQuery();
}
}
public override void Execute(AbstractDataTableFiller filler, DataTable table, ResultsLoaderProfile profile)
{
MonadAdapterFiller monadAdapterFiller = filler as MonadAdapterFiller;
if (monadAdapterFiller != null && !monadAdapterFiller.HasPermission() && (this.isResultPane || monadAdapterFiller.IsResolving))
{
return;
}
Stopwatch stopwatch = new Stopwatch();
this.BeginExecute(filler, profile);
MonadCommand monadCommand = null;
if (monadAdapterFiller != null)
{
monadCommand = monadAdapterFiller.Command;
}
else if (filler is SupervisionListFiller)
{
monadCommand = ((SupervisionListFiller)filler).Command;
}
if (monadCommand != null)
{
monadCommand.Connection = this.connection;
}
try
{
if (monadAdapterFiller != null)
{
ExTraceGlobals.DataFlowTracer.TracePerformance<string, Guid, RunspaceState>((long)Thread.CurrentThread.ManagedThreadId, "MonadScriptExecutionContext.Execute: In runspace {1}[State:{2}], before executing command '{0}' .", monadAdapterFiller.Command.CommandText, monadAdapterFiller.Command.Connection.RunspaceProxy.InstanceId, monadAdapterFiller.Command.Connection.RunspaceProxy.State);
stopwatch.Start();
}
filler.Fill(table);
}
catch (MonadDataAdapterInvocationException ex)
{
if (!(ex.InnerException is ManagementObjectNotFoundException) && !(ex.InnerException is MapiObjectNotFoundException))
{
throw;
}
}
finally
{
if (monadAdapterFiller != null)
{
stopwatch.Stop();
ExTraceGlobals.DataFlowTracer.TracePerformance((long)Thread.CurrentThread.ManagedThreadId, "MonadScriptExecutionContext.Execute: In the runspace {1}[State:{2}], {3} Milliseconds are taken to finish the command {0}.", new object[]
{
monadAdapterFiller.Command.CommandText,
monadAdapterFiller.Command.Connection.RunspaceProxy.InstanceId,
monadAdapterFiller.Command.Connection.RunspaceProxy.State,
stopwatch.ElapsedMilliseconds
});
}
this.EndExecute(filler, profile);
}
}
private void DetachCommandFromMonitorWarnings(MonadCommand command)
{
lock (this.workUnits)
{
WorkUnit workUnit;
if (this.TryGetWorkUnit(command.CommandText, out workUnit))
{
workUnit.Status = WorkUnitStatus.Completed;
command.WarningReport -= this.command_WarningReport;
}
}
}
protected override bool TryToGetPartialRefreshArgument(object[] ids, out object partialRefreshArgument)
{
if (1 != ids.Length)
{
throw new InvalidOperationException();
}
MonadCommand monadCommand = this.selectCommand.Clone();
monadCommand.Parameters.AddWithValue("Identity", ids[0]);
partialRefreshArgument = monadCommand;
return(true);
}
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);
}
private MonadCommand ClonePreparedCommand()
{
MonadParameter[] array = new MonadParameter[this.Parameters.Count];
this.Parameters.CopyTo(array, 0);
MonadParameter[] values = this.PrepareParameters();
this.Parameters.Clear();
this.Parameters.AddRange(values);
MonadCommand result = this.saveCommand.Clone();
this.Parameters.Clear();
this.Parameters.AddRange(array);
return(result);
}
private void FillParametersFromDataRow(MonadCommand command, DataRow row)
{
DataRowVersion version = (row.RowState == DataRowState.Deleted) ? DataRowVersion.Original : DataRowVersion.Current;
foreach (object obj in command.Parameters)
{
MonadParameter monadParameter = (MonadParameter)obj;
if (row.Table.Columns.Contains(monadParameter.ParameterName))
{
monadParameter.Value = row[monadParameter.ParameterName, version];
}
}
}
protected override bool TryToGetPartialRefreshArgument(object[] ids, out object partialRefreshArgument)
{
if (1 != ids.Length)
{
partialRefreshArgument = null;
return(false);
}
MonadCommand monadCommand = this.selectCommand.Clone();
monadCommand.Parameters.Clear();
monadCommand.Parameters.AddWithValue("Identity", ids[0]);
partialRefreshArgument = monadCommand;
return(true);
}
public bool IsCmdletAllowedInScope(MonadCommand command)
{
if (this.erc != null)
{
List <string> list = new List <string>(command.Parameters.Count);
foreach (object obj in command.Parameters)
{
MonadParameter monadParameter = (MonadParameter)obj;
list.Add(monadParameter.ParameterName);
}
return(this.IsCmdletAllowedInScope(command.CommandText, list.ToArray()));
}
return(true);
}
// 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);
}
protected override void OnDoRefreshWork(RefreshRequestEventArgs e)
{
MonadCommand monadCommand = e.Argument as MonadCommand;
if (monadCommand == null || monadCommand.Parameters.Contains("Identity") || (monadCommand.Parameters.Contains("server") && !string.IsNullOrEmpty((string)monadCommand.Parameters["server"].Value)))
{
base.OnDoRefreshWork(e);
return;
}
DataTable result = base.Table.Clone();
e.Result = result;
e.ReportProgress(100, 100, "", null);
}
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);
}
}
internal SingleTaskDataHandler(MonadCommand saveCommand)
{
this.saveCommand = saveCommand;
if (this.saveCommand == null)
{
throw new ArgumentNullException("saveCommand");
}
this.connection = saveCommand.Connection;
if (this.connection == null)
{
throw new ArgumentNullException("connection");
}
this.fields = new ADPropertyBag();
base.DataSource = this;
}
private void AttachCommandToMonitorWarnings(MonadCommand command)
{
lock (this.workUnits)
{
WorkUnit workUnit;
if (!this.TryGetWorkUnit(command.CommandText, out workUnit))
{
workUnit = new WorkUnit();
workUnit.Target = command;
workUnit.Text = command.CommandText;
this.workUnits.Add(workUnit);
command.WarningReport += this.command_WarningReport;
}
}
}
// 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);
}
public override void BuildParameters(DataRow row, DataObjectStore store, IList <ParameterProfile> paramInfos)
{
this.DataHandler.Parameters.Clear();
StringBuilder stringBuilder = new StringBuilder();
StringBuilder stringBuilder2 = new StringBuilder();
if ((bool)row[this.AutoDiscovery])
{
string text = MonadCommand.FormatParameterValue(row[this.AutoDiscoveryDomain]);
stringBuilder2.AppendFormat(this.AutoDiscoveryCommandText, text);
stringBuilder.Append(Strings.NameValueFormat(this.AutoDiscoveryDomain, text));
}
stringBuilder2.Append(this.originalCommandText);
stringBuilder2.Append(" ");
foreach (ParameterProfile parameterProfile in paramInfos)
{
if ((store.ModifiedColumns.Contains(parameterProfile.Reference) || this.Identity.Equals(parameterProfile.Name)) && parameterProfile.IsRunnable(row))
{
switch (parameterProfile.ParameterType)
{
case ParameterType.Switched:
stringBuilder2.AppendFormat("-{0} ", parameterProfile.Name);
stringBuilder.AppendLine(parameterProfile.Name);
break;
case ParameterType.Column:
case ParameterType.ModifiedColumn:
{
string text2 = MonadCommand.FormatParameterValue(MonadSaveTask.ConvertToParameterValue(row, parameterProfile.Reference));
stringBuilder.Append(Strings.NameValueFormat(parameterProfile.Name, text2));
if (this.Identity.Equals(parameterProfile.Name) && row[parameterProfile.Reference] is ADObjectId)
{
text2 = string.Format("'{0}'", ((ADObjectId)row[parameterProfile.Reference]).ObjectGuid.ToString());
}
stringBuilder2.AppendFormat("-{0} {1} ", parameterProfile.Name, text2);
break;
}
}
}
}
this.modifiedParametersDescription = stringBuilder.ToString();
this.DataHandler.CommandText = stringBuilder2.ToString();
this.DataHandler.ClearParameterNames();
}
// 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);
}
internal MonadCommand BuildProcedureWithScope(string commandText, string searchText, object[] pipeline, DataRow row, object scope)
{
MonadCommand monadCommand = this.InnerBuildProcedureCore(commandText, row);
if (!string.IsNullOrEmpty(searchText))
{
switch (this.SearchType)
{
case 0:
monadCommand.Parameters.AddWithValue("ANR", searchText);
break;
case 1:
monadCommand.Parameters.AddWithValue("Identity", string.Format("*{0}*", searchText));
break;
}
}
if (!string.IsNullOrEmpty(scope as string))
{
monadCommand.Parameters.AddWithValue("OrganizationalUnit", scope);
}
if (this.UseFilterToResolveNonId)
{
string pipelineFilterStringNotResolveIdentity = this.GetPipelineFilterStringNotResolveIdentity(pipeline);
if (!string.IsNullOrEmpty(pipelineFilterStringNotResolveIdentity))
{
string value = pipelineFilterStringNotResolveIdentity;
if (monadCommand.Parameters.Contains("Filter"))
{
value = string.Format("({0}) -and ({1})", pipelineFilterStringNotResolveIdentity, monadCommand.Parameters["Filter"].Value);
monadCommand.Parameters["Filter"].Value = value;
}
else
{
monadCommand.Parameters.AddWithValue("Filter", value);
}
}
}
return(monadCommand);
}
private void Fill(RefreshRequestEventArgs e)
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "-->DataTableLoader.Fill: {0}", this);
ResultsLoaderProfile profile = e.Argument as ResultsLoaderProfile;
if (profile != null)
{
DataTable dataTable = e.Result as DataTable;
dataTable.RowChanged += delegate(object sender, DataRowChangeEventArgs eventArgs)
{
if (eventArgs.Action == DataRowAction.Add)
{
this.FillPrimaryKeysBasedOnLambdaExpression(eventArgs.Row, profile);
}
};
DataTable dataTable2 = dataTable.Clone();
dataTable2.RowChanged += delegate(object sender, DataRowChangeEventArgs eventArgs)
{
if (eventArgs.Action == DataRowAction.Add)
{
this.FillPrimaryKeysBasedOnLambdaExpression(eventArgs.Row, profile);
}
};
if (!this.EnforeViewEntireForest && !profile.HasPermission())
{
goto IL_26F;
}
using (DataAdapterExecutionContext dataAdapterExecutionContext = this.executionContextFactory.CreateExecutionContext())
{
dataAdapterExecutionContext.Open(base.UIService, this.WorkUnits, this.EnforeViewEntireForest, profile);
foreach (AbstractDataTableFiller filler in profile.TableFillers)
{
if (profile.IsRunnable(filler))
{
if (e.CancellationPending)
{
break;
}
profile.BuildCommand(filler);
if (profile.FillType == 1 || this.IsPreFillForResolving(filler))
{
dataAdapterExecutionContext.Execute(filler, dataTable2, profile);
this.MergeChanges(dataTable2, dataTable);
dataTable2.Clear();
}
else
{
dataAdapterExecutionContext.Execute(filler, dataTable, profile);
}
}
}
goto IL_26F;
}
}
MonadCommand monadCommand = e.Argument as MonadCommand;
if (monadCommand != null)
{
this.AttachCommandToMonitorWarnings(monadCommand);
using (MonadConnection monadConnection = new MonadConnection(PSConnectionInfoSingleton.GetInstance().GetConnectionStringForScript(), new CommandInteractionHandler(), ADServerSettingsSingleton.GetInstance().CreateRunspaceServerSettingsObject(), PSConnectionInfoSingleton.GetInstance().GetMonadConnectionInfo(ExchangeRunspaceConfigurationSettings.SerializationLevel.Full)))
{
monadConnection.Open();
monadCommand.Connection = monadConnection;
using (MonadDataAdapter monadDataAdapter = new MonadDataAdapter(monadCommand))
{
DataTable dataTable3 = (DataTable)e.Result;
if (dataTable3.Columns.Count != 0)
{
monadDataAdapter.MissingSchemaAction = MissingSchemaAction.Ignore;
monadDataAdapter.EnforceDataSetSchema = true;
}
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, MonadCommand>((long)this.GetHashCode(), "-->DataTableLoader.Fill: calling dataAdapter.Fill: {0}. Command:{1}", this, monadCommand);
monadDataAdapter.Fill(dataTable3);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, MonadCommand>((long)this.GetHashCode(), "<--DataTableLoader.Fill: calling dataAdaptr.Fill: {0}. Command:{1}", this, monadCommand);
}
}
this.DetachCommandFromMonitorWarnings(monadCommand);
}
IL_26F:
this.OnFillTable(e);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "<--DataTableLoader.Fill: {0}", this);
}
private bool InternalExecuteScript(string script, bool handleError, int subSteps, LocalizedString statusDescription)
{
bool result = false;
WorkUnit workUnit = new WorkUnit();
bool newSubProgressReceived = false;
int completedSubSteps = 0;
try
{
script.TrimEnd(new char[]
{
'\n'
});
string script2 = script.Replace("\n", "\r\n");
if (handleError)
{
base.WriteVerbose(Strings.ExecutingScriptNonFatal(script2));
}
else
{
base.WriteVerbose(Strings.ExecutingScript(script2));
}
script = string.Format("$error.Clear(); {0}", script);
MonadCommand monadCommand = new MonadCommand(script, this.monadConnection);
monadCommand.CommandType = CommandType.Text;
monadCommand.ProgressReport += delegate(object sender, ProgressReportEventArgs e)
{
if (subSteps == 0)
{
return;
}
completedSubSteps = subSteps * e.ProgressRecord.PercentComplete / 100;
newSubProgressReceived = true;
};
bool flag = false;
try
{
TaskLogger.IncreaseIndentation();
TaskLogger.LogErrorAsWarning = handleError;
MonadAsyncResult monadAsyncResult = monadCommand.BeginExecute(new WorkUnit[]
{
workUnit
});
while (!flag)
{
flag = monadAsyncResult.AsyncWaitHandle.WaitOne(200, false);
if (newSubProgressReceived)
{
base.WriteProgress(this.Description, statusDescription, (this.completedSteps + completedSubSteps) * 100 / this.totalSteps);
newSubProgressReceived = false;
}
if (base.Stopping)
{
break;
}
}
if (base.Stopping)
{
monadCommand.Cancel();
}
else
{
monadCommand.EndExecute(monadAsyncResult);
}
}
catch (CommandExecutionException ex)
{
if (ex.InnerException != null)
{
throw new ScriptExecutionException(Strings.ErrorCommandExecutionException(script, ex.InnerException.ToString()), ex.InnerException);
}
throw;
}
finally
{
TaskLogger.DecreaseIndentation();
}
this.completedSteps += subSteps;
result = true;
}
catch (CmdletInvocationException ex2)
{
result = false;
if (!handleError)
{
throw;
}
base.WriteVerbose(Strings.IgnoringException(ex2.ToString()));
base.WriteVerbose(Strings.WillContinueProcessing);
}
if (workUnit.Errors.Count > 0)
{
result = false;
int count = workUnit.Errors.Count;
base.WriteVerbose(Strings.ErrorDuringTaskExecution(count));
for (int i = 0; i < count; i++)
{
ErrorRecord errorRecord = workUnit.Errors[i];
base.WriteVerbose(Strings.ErrorRecordReport(errorRecord.ToString(), i));
if (!handleError)
{
base.WriteVerbose(Strings.ErrorRecordReport(errorRecord.Exception.ToString(), i));
ScriptExecutionException exception = new ScriptExecutionException(Strings.ErrorCommandExecutionException(script, errorRecord.Exception.ToString()), errorRecord.Exception);
this.WriteError(exception, errorRecord.CategoryInfo.Category, errorRecord.TargetObject, false);
}
}
if (handleError)
{
base.WriteVerbose(Strings.WillIgnoreNoncriticalErrors);
base.WriteVerbose(Strings.WillContinueProcessing);
}
}
return(result);
}
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();
}
}
