internal PowerShellResults <JsonDictionary <object> > GetProgress(string progressId, bool async)
{
string text = this.workflow ?? "GetProgress";
if (!string.IsNullOrEmpty(this.schema) && this.IsWorkflowDefined(text))
{
return(this.ExecuteProgressWorkflow(text, progressId));
}
if (async)
{
DDIHelper.ProgressIdForGetListAsync = progressId;
DDIParameters ddiparameters = new DDIParameters();
AsyncGetListContext registeredContext = AsyncServiceManager.GetRegisteredContext(progressId);
Dictionary <string, object> dictionary;
if (registeredContext != null && registeredContext.Parameters != null && registeredContext.Parameters.Parameters != null)
{
dictionary = registeredContext.Parameters.Parameters.RawDictionary;
}
else
{
dictionary = new Dictionary <string, object>();
}
if (registeredContext != null && !string.IsNullOrEmpty(registeredContext.WorkflowOutput))
{
dictionary["workflowOutput"] = registeredContext.WorkflowOutput;
}
dictionary["ProgressId"] = progressId;
ddiparameters.Parameters = new JsonDictionary <object>(dictionary);
return(this.GetListCommon(ddiparameters, null, true));
}
return(AsyncServiceManager.GetProgress(progressId));
}
public sealed override bool IsRunnable(DataRow input, DataTable dataTable, DataObjectStore store)
{
if (AsyncServiceManager.IsCurrentWorkCancelled())
{
return(false);
}
List <Parameter> parametersToInvoke = this.GetParametersToInvoke(input, dataTable, store);
bool flag = this.IsToExecuteCmdlet(input, dataTable, store, parametersToInvoke);
if (!flag)
{
return(false);
}
List <string> parameters = (from x in parametersToInvoke
select x.Name).ToList <string>();
string cmdletRbacString = this.GetCmdletRbacString(store, parameters);
bool flag2 = base.RbacChecker.IsInRole(cmdletRbacString);
DDIHelper.Trace("Checking RBAC: {0} : {1}", new object[]
{
cmdletRbacString,
flag2
});
if (!flag2)
{
throw new CmdletAccessDeniedException(Strings.AccessDeniedMessage);
}
return(true);
}
public PowerShellResults <JsonDictionary <object> > Execute()
{
PowerShellResults <JsonDictionary <object> > result;
using (EcpPerformanceData.DDIServiceExecution.StartRequestTimer())
{
switch (this.ExecutingWorkflow.AsyncMode)
{
case AsyncMode.AsynchronousOnly:
this.ExecutingWorkflow.AsyncRunning = true;
break;
case AsyncMode.SynchronousAndAsynchronous:
this.ExecutingWorkflow.AsyncRunning = (base.DataObjectStore.AsyncType == ListAsyncType.GetListAsync || base.DataObjectStore.AsyncType == ListAsyncType.GetListPreLoad);
break;
}
if (!this.ExecutingWorkflow.AsyncRunning || DDIHelper.ForGetListProgress)
{
result = this.ExecuteCore(this.ExecutingWorkflow);
}
else
{
if (!typeof(ProgressCalculatorBase).IsAssignableFrom(this.ExecutingWorkflow.ProgressCalculator))
{
throw new ArgumentException("A valid ProgressCalculator type must be specified for async running workflow.");
}
Func <PowerShellResults> callback = delegate()
{
IList <string> outputVariables = this.GetOutputVariables(this.OutputVariableWorkflow);
AsyncGetListContext asyncGetListContext = new AsyncGetListContext
{
WorkflowOutput = string.Join(",", outputVariables ?? ((IList <string>)Array <string> .Empty)),
UnicodeOutputColumnNames = this.GetUnicodeVariablesFrom(outputVariables),
Parameters = this.parameters
};
AsyncServiceManager.RegisterWorkflow(this.ExecutingWorkflow, asyncGetListContext);
return(this.ExecuteCore(this.ExecutingWorkflow));
};
AsyncTaskType taskType = AsyncTaskType.Default;
string text = this.ExecutingWorkflow.Name;
if (base.DataObjectStore.AsyncType == ListAsyncType.GetListAsync)
{
taskType = AsyncTaskType.AsyncGetList;
}
else if (base.DataObjectStore.AsyncType == ListAsyncType.GetListPreLoad)
{
taskType = AsyncTaskType.AsyncGetListPreLoad;
text += "_PreLoad";
}
PowerShellResults powerShellResults = AsyncServiceManager.InvokeAsync(callback, null, this.UniqueLogonUserIdentity, taskType, text);
result = new PowerShellResults <JsonDictionary <object> >
{
ProgressId = powerShellResults.ProgressId,
ErrorRecords = powerShellResults.ErrorRecords
};
}
}
return(result);
}
internal PowerShellResults Cancel(string progressId)
{
string text = this.workflow ?? "Cancel";
if (!string.IsNullOrEmpty(this.schema) && this.IsWorkflowDefined(text))
{
return(this.ExecuteProgressWorkflow(text, progressId));
}
return(AsyncServiceManager.Cancel(progressId));
}
public override RunResult Run(DataRow input, DataTable dataTable, DataObjectStore store, Type codeBehind, Workflow.UpdateTableDelegate updateTableDelegate)
{
DDIHelper.Trace(TraceType.InfoTrace, "Executing :" + base.GetType().Name);
DDIHelper.Trace <IPSCommandWrapper>(TraceType.InfoTrace, base.Command);
RunResult runResult = new RunResult();
PowerShellResults <PSObject> powerShellResults;
if (!DDIHelper.ForGetListProgress)
{
base.ExecuteCmdlet(null, runResult, out powerShellResults, store.AsyncType == ListAsyncType.GetListAsync || store.AsyncType == ListAsyncType.GetListPreLoad);
}
else if (store.AsyncType == ListAsyncType.GetListEndLoad)
{
powerShellResults = AsyncServiceManager.GetPreLoadResult(DDIHelper.ProgressIdForGetListAsync);
}
else
{
string progressIdForGetListAsync = DDIHelper.ProgressIdForGetListAsync;
powerShellResults = AsyncServiceManager.GetCurrentResult(progressIdForGetListAsync);
}
base.StatusReport = powerShellResults;
runResult.ErrorOccur = !base.StatusReport.Succeeded;
if (!runResult.ErrorOccur)
{
if (powerShellResults.Output != null && powerShellResults.Output.Length > 0)
{
Type type = null;
Hashtable propertyHash = new Hashtable();
Hashtable hashtable = new Hashtable();
dataTable.BeginLoadData();
foreach (PSObject psobject in powerShellResults.Output)
{
if (type == null)
{
type = psobject.BaseObject.GetType();
type.GetProperties().Perform(delegate(PropertyInfo c)
{
propertyHash[c.Name] = c;
});
}
DataRow dataRow = dataTable.NewRow();
dataTable.Rows.Add(dataRow);
dataRow.BeginEdit();
foreach (object obj in dataTable.Columns)
{
DataColumn dataColumn = (DataColumn)obj;
Variable variable = dataColumn.ExtendedProperties["Variable"] as Variable;
if (variable != null)
{
if (variable.PersistWholeObject)
{
dataRow[dataColumn.ColumnName] = psobject.BaseObject;
}
else if (!hashtable.ContainsKey(dataColumn.ColumnName))
{
PropertyInfo propertyInfo = propertyHash[variable.MappingProperty] as PropertyInfo;
if (propertyInfo != null)
{
dataRow[dataColumn.ColumnName] = propertyInfo.GetValue(psobject.BaseObject, null);
}
else
{
hashtable.Add(dataColumn.ColumnName, null);
}
}
}
}
Collection <Set> defaultValues = this.DefaultValues;
NewDefaultObject.SetDefaultValues(input, dataRow, dataTable, defaultValues);
dataRow.EndEdit();
}
dataTable.EndLoadData();
}
}
else if (this.isResultSizeAutoApplied)
{
Microsoft.Exchange.Management.ControlPanel.ErrorRecord errorRecord = base.StatusReport.ErrorRecords.FirstOrDefault((Microsoft.Exchange.Management.ControlPanel.ErrorRecord x) => x.Exception is ParameterBindingException && (x.Exception as ParameterBindingException).ParameterName == "ResultSize");
if (errorRecord != null)
{
if (base.StatusReport.ErrorRecords.Length > 1)
{
base.StatusReport.ErrorRecords = base.StatusReport.ErrorRecords.Except(new Microsoft.Exchange.Management.ControlPanel.ErrorRecord[]
{
errorRecord
}).ToArray <Microsoft.Exchange.Management.ControlPanel.ErrorRecord>();
}
else
{
base.StatusReport.ErrorRecords = new Microsoft.Exchange.Management.ControlPanel.ErrorRecord[]
{
new Microsoft.Exchange.Management.ControlPanel.ErrorRecord(new Exception(Strings.UnsupportedAutoApplyParamMsgText))
};
}
lock (GetListCmdlet.unsupportedCmdletsLock)
{
string commandText = base.GetCommandText(store);
if (!GetListCmdlet.unsupportedCmdlets.Contains(commandText))
{
GetListCmdlet.unsupportedCmdlets.Add(commandText);
}
}
}
}
return(runResult);
}
protected override PowerShellResults <JsonDictionary <object> > ExecuteCore(Workflow workflow)
{
DataRow row = base.Table.NewRow();
base.Table.Rows.Add(row);
base.Row.ItemArray = base.Input.ItemArray;
PowerShellResults <JsonDictionary <object> > powerShellResults = new PowerShellResults <JsonDictionary <object> >();
powerShellResults.MergeErrors(workflow.Run(base.Input, base.Table, base.DataObjectStore, base.ProfileBuilder.Class, new Workflow.UpdateTableDelegate(this.UpdateTable)));
if (powerShellResults.ErrorRecords.Length == 0)
{
if (workflow.AsyncRunning && AsyncServiceManager.IsCurrentWorkCancelled())
{
goto IL_451;
}
using (EcpPerformanceData.DDITypeConversion.StartRequestTimer())
{
IList <string> outputVariables = base.GetOutputVariables(base.OutputVariableWorkflow);
Func <DataColumn, bool> predicate;
if (this.IsGetObjectForNew)
{
predicate = ((DataColumn c) => outputVariables.Contains(c.ColumnName, StringComparer.OrdinalIgnoreCase) && this.Row[c.ColumnName] != DBNull.Value);
}
else
{
predicate = ((DataColumn c) => outputVariables.Contains(c.ColumnName, StringComparer.OrdinalIgnoreCase) || (Variable.MandatoryVariablesForGetObject.Contains(c.ColumnName) && this.ExecutingWorkflow is GetObjectWorkflow));
}
IEnumerable <DataColumn> columns = (outputVariables == null) ? base.Table.Columns.Cast <DataColumn>() : base.Table.Columns.Cast <DataColumn>().Where(predicate);
Dictionary <string, object> dictionary;
base.ExtractDataRow(base.Table.Rows[0], columns, out dictionary);
if (base.ExecutingWorkflow is GetObjectWorkflow)
{
foreach (string name in this.GetOutputRelatedDataObjects(columns))
{
IVersionable versionable = base.DataObjectStore.GetDataObject(name) as IVersionable;
if (versionable != null && versionable.ExchangeVersion != null)
{
bool flag = versionable.ExchangeVersion.IsOlderThan(base.DataObjectStore.GetDataObjectDeclaration(name).MinSupportedVersion);
if (versionable.IsReadOnly || flag)
{
base.Table.Rows[0]["IsReadOnly"] = true;
if (dictionary.ContainsKey("IsReadOnly"))
{
dictionary["IsReadOnly"] = true;
}
string text = flag ? Strings.ObjectTooOld : Strings.VersionMismatchWarning(versionable.ExchangeVersion.ExchangeBuild);
powerShellResults.Warnings = ((powerShellResults.Warnings == null) ? new string[]
{
text
} : powerShellResults.Warnings.Concat(new string[]
{
text
}).ToArray <string>());
break;
}
}
}
}
Dictionary <string, ValidatorInfo[]> dictionary2;
IList <string> source;
IList <string> source2;
workflow.LoadMetaData(base.Input, base.Table, base.DataObjectStore, outputVariables, out dictionary2, out source, out source2, base.ProfileBuilder);
powerShellResults.Validators = dictionary2;
powerShellResults.ReadOnlyProperties = source.ToArray <string>();
powerShellResults.NoAccessProperties = source2.ToArray <string>();
powerShellResults.Output = new JsonDictionary <object>[]
{
dictionary
};
goto IL_451;
}
}
ShouldContinueException ex = powerShellResults.ErrorRecords[0].Exception as ShouldContinueException;
if (ex != null)
{
ShouldContinueContext shouldContinueContext = (HttpContext.Current.Items["ShouldContinueContext"] as ShouldContinueContext) ?? new ShouldContinueContext();
if (!shouldContinueContext.CmdletsPrompted.Contains(ex.Details.CurrentCmdlet))
{
shouldContinueContext.CmdletsPrompted.Add(ex.Details.CurrentCmdlet);
}
powerShellResults.ErrorRecords[0].Context = shouldContinueContext;
}
if (!workflow.OutputOnError.IsNullOrEmpty())
{
IEnumerable <DataColumn> columns2 = from DataColumn c in base.Table.Columns
where workflow.OutputOnError.Contains(c.ColumnName)
select c;
Dictionary <string, object> dictionary3;
base.ExtractDataRow(base.Table.Rows[0], columns2, out dictionary3);
if (powerShellResults.ErrorRecords[0].Context == null)
{
powerShellResults.ErrorRecords[0].Context = new ErrorRecordContext();
}
powerShellResults.ErrorRecords[0].Context.LastOuput = dictionary3;
}
IL_451:
DDIHelper.Trace(TraceType.InfoTrace, "Result: ");
DDIHelper.Trace <PowerShellResults <JsonDictionary <object> > >(TraceType.InfoTrace, powerShellResults);
return(powerShellResults);
}
public virtual bool IsRunnable(DataRow input, DataTable dataTable, DataObjectStore store)
{
return(!AsyncServiceManager.IsCurrentWorkCancelled() && this.HasPermission(input, dataTable, store, null));
}
