internal static object PrepareVariableForSerialization(object value, Variable variable)
{
value = (DBNull.Value.Equals(value) ? null : value);
if (variable.OutputConverter != null && variable.OutputConverter.CanConvert(value))
{
value = variable.OutputConverter.Convert(value);
}
else
{
value = DDIHelper.TryStrongTypeConversion(value);
}
if (variable.Type == typeof(bool) && value == null)
{
value = false;
}
else if (variable.Type == typeof(string) && value == null)
{
value = string.Empty;
}
else if (value is DateTime)
{
value = ((DateTime)value).LocalToUserDateTimeString();
}
return(value);
}
public static bool IsEmptyValue(object propertyValue)
{
bool result = false;
if (propertyValue == null)
{
result = true;
}
else if (DBNull.Value.Equals(propertyValue))
{
result = true;
}
else if (propertyValue is IEnumerable && DDIHelper.IsEmptyCollection(propertyValue as IEnumerable))
{
result = true;
}
else if (propertyValue is Guid && Guid.Empty.Equals(propertyValue))
{
result = true;
}
else if (string.IsNullOrEmpty(propertyValue.ToString()))
{
result = true;
}
return(result);
}
public static object ConvertToParameterValue(DataRow input, DataTable dataTable, Parameter paramInfo, DataObjectStore store)
{
string variableName = paramInfo.Reference ?? paramInfo.Name;
object obj;
if (paramInfo.Value == null)
{
obj = DDIHelper.GetVariableValue(store.ModifiedColumns, variableName, input, dataTable, store.IsGetListWorkflow);
}
else
{
string text = paramInfo.Value as string;
if (DDIHelper.IsLambdaExpression(text))
{
obj = ExpressionCalculator.CalculateLambdaExpression(ExpressionCalculator.BuildColumnExpression(text), typeof(object), DDIHelper.GetLambdaExpressionDataRow(dataTable), input);
}
else
{
VariableReference variableReference = paramInfo.Value as VariableReference;
if (variableReference != null)
{
obj = DDIHelper.GetVariableValue(variableReference, input, dataTable);
}
else
{
obj = paramInfo.Value;
}
}
}
if (obj == DBNull.Value)
{
return(null);
}
return(obj);
}
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);
}
protected void FillColumnsBasedOnLambdaExpression(DataRow row, Variable variable)
{
if (DDIHelper.IsLambdaExpression(variable.Value as string))
{
this.FillColumns(row, this.GetExpressionCalculator().CalculateSpecifiedColumn(variable.Name, row, this.Input));
}
}
public static void GetConnectionFilterPostAction(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
if (dataTable.Rows.Count == 0)
{
return;
}
DataRow dataRow = dataTable.Rows[0];
List <IPAddressEntry> list = new List <IPAddressEntry>();
List <IPAddressEntry> list2 = new List <IPAddressEntry>();
if (!DDIHelper.IsEmptyValue(dataRow["IPAllowList"]))
{
foreach (IPRange range in ((MultiValuedProperty <IPRange>)dataRow["IPAllowList"]))
{
list.Add(new IPAddressEntry(range));
}
}
if (!DDIHelper.IsEmptyValue(dataRow["IPBlockList"]))
{
foreach (IPRange range2 in ((MultiValuedProperty <IPRange>)dataRow["IPBlockList"]))
{
list2.Add(new IPAddressEntry(range2));
}
}
dataRow["IPAllowList"] = list;
dataRow["IPBlockList"] = list2;
}
internal bool IsAccessingVariable(string accessingVariable)
{
List <string> list = new List <string>();
if (this.Value != null)
{
VariableReference variableReference = this.Value as VariableReference;
if (variableReference != null)
{
list.Add(variableReference.Variable);
}
else
{
string text = this.Value as string;
if (DDIHelper.IsLambdaExpression(text))
{
list.AddRange(ExpressionCalculator.BuildColumnExpression(text).DependentColumns);
}
}
}
else
{
list.Add(this.Reference ?? this.Name);
}
return(list.Any((string c) => string.Equals(c, accessingVariable, StringComparison.OrdinalIgnoreCase)));
}
public static string Join(object separator, object value)
{
if (DDIHelper.IsEmptyValue(value))
{
return(string.Empty);
}
List <object> list = value as List <object>;
if (DDIHelper.IsEmptyValue(list))
{
return(string.Empty);
}
if (separator == null || separator.ToString() == null)
{
separator = string.Empty;
}
StringBuilder stringBuilder = new StringBuilder();
foreach (object obj in list)
{
if (!DDIHelper.IsEmptyValue(obj) && !DDIHelper.IsEmptyValue(obj.ToString()))
{
if (stringBuilder.Length != 0)
{
stringBuilder.Append(separator);
}
stringBuilder.Append(obj.ToString());
}
}
return(stringBuilder.ToString());
}
internal static void Trace <T>(TraceType traceType, T obj)
{
if (obj != null && DDIHelper.HasTraceEnabled(traceType))
{
DDIHelper.Trace(traceType, EcpTraceHelper.GetTraceString(obj));
}
}
public static void ClearOutputForOlderVersion(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
HybridConfiguration hybridConfiguration = store.GetDataObject("HybridConfiguration") as HybridConfiguration;
IntraOrganizationConfiguration intraOrganizationConfiguration = store.GetDataObject("IntraOrganizationConfiguration") as IntraOrganizationConfiguration;
bool flag = hybridConfiguration != null && DDIHelper.IsLegacyObject(hybridConfiguration);
if (flag)
{
dataTable.Rows.Clear();
store.UpdateDataObject("HybridConfiguration", null);
DataRow row = dataTable.NewRow();
dataTable.Rows.Add(row);
}
dataTable.Rows[0]["NeedUpgrade"] = flag;
if (object.Equals(dataTable.Rows[0]["IncomingServiceInstance"], "1"))
{
inputRow["IsGallatin"] = (dataTable.Rows[0]["IsGallatin"] = true);
if (OrganizationCache.RestrictIOCToSP1OrGreaterGallatin && intraOrganizationConfiguration.DeploymentIsCompleteIOCReady == false)
{
dataTable.Rows[0]["GallatinBlock"] = true;
return;
}
}
else if (!OrganizationCache.RestrictIOCToSP1OrGreaterWorldWide || intraOrganizationConfiguration.DeploymentIsCompleteIOCReady == true)
{
dataTable.Rows[0]["WWoAuth"] = true;
}
}
internal void ExecuteCmdlet(IEnumerable pipelineInput, RunResult runResult, out PowerShellResults <PSObject> result, bool isGetListAsync = false)
{
DDIHelper.Trace(TraceType.InfoTrace, "Executing :" + base.GetType().Name);
DDIHelper.Trace(TraceType.InfoTrace, "Task: {0}", new object[]
{
this.Command
});
DDIHelper.Trace(TraceType.InfoTrace, "Pipeline: {0}", new object[]
{
pipelineInput
});
WebServiceParameters parameters = null;
if (this.AllowExceuteThruHttpGetRequest)
{
parameters = CmdletActivity.allowExceuteThruHttpGetRequestParameters;
}
result = this.Command.Invoke <PSObject>(DataSourceService.UserRunspaces, pipelineInput, parameters, this, isGetListAsync);
if (this.DisableLogging)
{
result.CmdletLogInfo = null;
}
this.StatusReport = result;
runResult.ErrorOccur = !this.StatusReport.Succeeded;
}
private static Hashtable ConvertToHashTable(object identities, string addOrRemoveforKeyName)
{
Hashtable result = new Hashtable();
if (identities == null || identities == DBNull.Value)
{
return(result);
}
object[] array = identities as object[];
if (array == null || array.Length == 0)
{
DDIHelper.ThrowIllegalInput();
}
if (string.IsNullOrWhiteSpace(addOrRemoveforKeyName) || (!addOrRemoveforKeyName.Equals("add", StringComparison.OrdinalIgnoreCase) && !addOrRemoveforKeyName.Equals("remove", StringComparison.OrdinalIgnoreCase)))
{
DDIHelper.ThrowIllegalHashtableKeyType(addOrRemoveforKeyName);
}
Hashtable hashtable = new Hashtable();
string[] array2 = new string[array.Length];
for (int i = 0; i < array.Length; i++)
{
Identity identity = array[i] as Identity;
if (identity == null)
{
DDIHelper.ThrowIllegalInput();
}
array2[i] = identity.RawIdentity;
}
hashtable.Add(addOrRemoveforKeyName, array2);
return(hashtable);
}
public static CustomMenuKeyMapping[] UMAAMenuKeyMappingToTask(object value)
{
if (!DDIHelper.IsEmptyValue(value))
{
return(Array.ConvertAll <object, CustomMenuKeyMapping>((object[])value, (object x) => ((UMAAMenuKeyMapping)x).ToCustomKeyMapping()));
}
return(null);
}
public static string[] UMDialingRuleEntryToTask(object value)
{
if (!DDIHelper.IsEmptyValue(value))
{
return(UMDialingRuleEntry.GetStringArray(Array.ConvertAll <object, UMDialingRuleEntry>((object[])value, (object x) => (UMDialingRuleEntry)x)));
}
return(null);
}
public static HolidaySchedule[] UMAAHolidayScheduleToTask(object value)
{
if (!DDIHelper.IsEmptyValue(value))
{
return(Array.ConvertAll <object, HolidaySchedule>((object[])value, (object x) => ((UMAAHolidaySchedule)x).ToHolidaySchedule()));
}
return(null);
}
private IEnumerable <string> GetOutputRelatedDataObjects(IEnumerable <DataColumn> columns)
{
IEnumerable <string> variables = DDIHelper.GetOutputRawVariables(columns);
return((from c in base.ProfileBuilder.Variables
where variables.Contains(c.Name) && !string.IsNullOrWhiteSpace(c.DataObjectName)
select c.DataObjectName).Distinct <string>());
}
protected override PowerShellResults <JsonDictionary <object> > ExecuteCore(Workflow workflow)
{
PowerShellResults <JsonDictionary <object> > powerShellResults = new PowerShellResults <JsonDictionary <object> >();
PowerShellResults powerShellResults2 = workflow.Run(base.Input, base.Table, base.DataObjectStore, base.ProfileBuilder.Class, delegate(string result, bool fillAllColumns)
{
});
powerShellResults.MergeErrors(powerShellResults2);
powerShellResults.MergeProgressData <JsonDictionary <object> >(powerShellResults2 as PowerShellResults <JsonDictionary <object> >);
if (powerShellResults.ErrorRecords.Length == 0)
{
using (EcpPerformanceData.DDITypeConversion.StartRequestTimer())
{
Dictionary <string, object> dictionary = null;
List <JsonDictionary <object> > list = new List <JsonDictionary <object> >();
IList <string> outputList = base.GetOutputVariables(base.OutputVariableWorkflow);
DataColumn[] columns = (from DataColumn c in base.Table.Columns
where outputList == null || outputList.Contains(c.ColumnName, StringComparer.OrdinalIgnoreCase)
select c).ToArray <DataColumn>();
foreach (object obj in base.Table.DefaultView)
{
DataRowView dataRowView = (DataRowView)obj;
base.ExtractDataRow(dataRowView.Row, columns, out dictionary);
list.Add(dictionary);
}
this.AddSortDataToResult(powerShellResults, list, outputList);
if (this.sortOptions != null && outputList.Contains(this.sortOptions.PropertyName))
{
Func <JsonDictionary <object>[], JsonDictionary <object>[]> ddisortFunction = this.sortOptions.GetDDISortFunction();
powerShellResults.Output = ddisortFunction(list.ToArray());
}
else
{
powerShellResults.Output = list.ToArray();
}
GetListWorkflow getListWorkflow = workflow as GetListWorkflow;
if (getListWorkflow != null)
{
int resultSizeInt = getListWorkflow.GetResultSizeInt32(base.Input, base.Table);
if (resultSizeInt > 0 && resultSizeInt < list.Count)
{
powerShellResults.Output = powerShellResults.Output.Take(resultSizeInt).ToArray <JsonDictionary <object> >();
if (!powerShellResults.Warnings.Contains(Strings.WarningMoreResultsAvailable))
{
powerShellResults.Warnings = powerShellResults.Warnings.Concat(new string[]
{
Strings.WarningMoreResultsAvailable
}).ToArray <string>();
}
}
}
}
}
DDIHelper.Trace(TraceType.InfoTrace, "Result: ");
DDIHelper.Trace <PowerShellResults <JsonDictionary <object> > >(TraceType.InfoTrace, powerShellResults);
return(powerShellResults);
}
internal static object GetVariableValue(VariableReference variableReference, DataRow input, DataTable dataTable)
{
if (variableReference.UseInput)
{
return(DDIHelper.ConvertDBNullToNull(input, variableReference.Variable));
}
DDIHelper.CheckDataTableForSingleObject(dataTable);
return(DDIHelper.ConvertDBNullToNull(dataTable.Rows[0], variableReference.Variable));
}
public static bool IsUnlimited(object value)
{
if (DDIHelper.IsEmptyValue(value))
{
return(false);
}
Type type = value.GetType();
return((bool)type.GetProperty("IsUnlimited").GetValue(value, null));
}
public static void GetListPostAction(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
dataTable.BeginLoadData();
foreach (object obj in dataTable.Rows)
{
DataRow dataRow = (DataRow)obj;
dataRow["FormattedDomainNames"] = DDIHelper.JoinList <SmtpDomain>(dataRow["DomainNames"] as MultiValuedProperty <SmtpDomain>, (SmtpDomain domain) => domain.Domain);
}
dataTable.EndLoadData();
}
public override void CalculateProgressImpl(ProgressReportEventArgs e)
{
DDIHelper.Trace("In CalculateProgress: " + e.Percent);
base.ProgressRecord.Percent = e.Percent;
base.ProgressRecord.Status = e.Status;
if (e.Errors != null)
{
base.ProgressRecord.Errors = ((base.ProgressRecord.Errors == null) ? e.Errors.ToArray <ErrorRecord>() : base.ProgressRecord.Errors.Concat(e.Errors.ToArray <ErrorRecord>() ?? new ErrorRecord[0]).ToArray <ErrorRecord>());
}
}
public override bool IsRunnable(DataRow input, DataTable dataTable, DataObjectStore store)
{
if (!base.IsRunnable(input, dataTable, store))
{
return(false);
}
DDIHelper.CheckDataTableForSingleObject(dataTable);
object variableValue = DDIHelper.GetVariableValue(store.ModifiedColumns, this.Collection, input, dataTable, store.IsGetListWorkflow);
return(variableValue is IEnumerable <object> && (variableValue as IEnumerable <object>).Count <object>() > 0);
}
public static string ToDaysString(object value)
{
string result = string.Empty;
if (!DDIHelper.IsEmptyValue(value))
{
Unlimited <EnhancedTimeSpan> unlimited = (Unlimited <EnhancedTimeSpan>)value;
result = (unlimited.IsUnlimited ? unlimited.ToString() : unlimited.Value.Days.ToString());
}
return(result);
}
public virtual void InputValue(string columnName, object value)
{
Variable variable = base.Table.Columns[columnName].ExtendedProperties["Variable"] as Variable;
if (variable != null && variable.InputConverter != null && variable.InputConverter.CanConvert(value))
{
value = variable.InputConverter.Convert(value);
}
DDIHelper.Trace(" Initial value: " + EcpTraceExtensions.FormatParameterValue(value) + ", Column: " + columnName);
base.Input[columnName] = value;
}
public static void SetHybridConfigurationEnabled(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
HybridConfiguration hybridConfiguration = store.GetDataObject("HybridConfiguration") as HybridConfiguration;
bool flag = hybridConfiguration != null && !DDIHelper.IsLegacyObject(hybridConfiguration);
dataTable.Rows[0]["HybridConfigurationEnabled"] = flag;
if (flag)
{
dataTable.Rows[0]["IsHostedOnGallatin"] = (hybridConfiguration.ServiceInstance == 1);
}
}
private static void UpdateFormattedNameAndDomains(DataRow row)
{
row["FormattedName"] = (true.Equals(row["Default"]) ? string.Format(Strings.DefaultSharingPolicyFormatString, row["Name"]) : row["Name"]);
row["FormattedDomains"] = DDIHelper.JoinList <SharingPolicyDomain>(row["Domains"] as MultiValuedProperty <SharingPolicyDomain>, delegate(SharingPolicyDomain policyDomain)
{
if (policyDomain.Domain == "*")
{
return(Strings.SharingDomainOptionAll);
}
return(policyDomain.Domain);
});
}
private static void SetDate(DataRow row, List <string> modifiedColumns, string propertyName, string dateString)
{
ExDateTime?utcExDateTime = DiscoveryHoldPropertiesHelper.GetUtcExDateTime(dateString);
if (utcExDateTime != null)
{
row[propertyName] = utcExDateTime.Value.ToUtc();
modifiedColumns.Add(propertyName);
return;
}
DDIHelper.Trace(string.Format("{0} was not set because an expected date {1} resulted in null.", propertyName, dateString));
}
public static int Length(object value)
{
if (!DDIHelper.IsEmptyValue(value))
{
Array array = value as Array;
if (array != null)
{
return(array.Length);
}
}
return(0);
}
public static void PreGetListAction(DataRow inputrow, DataTable dataTable, DataObjectStore store)
{
ExDateTime exDateTime = ExDateTime.Now;
ExDateTime exDateTime2 = ExDateTime.Now;
if (!DDIHelper.IsEmptyValue(inputrow["DateRangeType"]))
{
string a;
if ((a = inputrow["DateRangeType"].ToString()) != null)
{
if (a == "24h")
{
exDateTime = ExDateTime.Now.AddHours(-24.0);
goto IL_13F;
}
if (a == "7d")
{
exDateTime = ExDateTime.Now.AddDays(-7.0);
goto IL_13F;
}
if (a == "custom")
{
ExTimeZone utcTimeZone = ExTimeZone.UtcTimeZone;
if (!DDIHelper.IsEmptyValue(inputrow["TimeZone"]))
{
ExTimeZoneEnumerator.Instance.TryGetTimeZoneByName(inputrow["TimeZone"].ToString(), out utcTimeZone);
}
if (!DDIHelper.IsEmptyValue(inputrow["StartDate"]))
{
exDateTime = ExDateTime.Parse(utcTimeZone, inputrow["StartDate"].ToString());
}
if (!DDIHelper.IsEmptyValue(inputrow["EndDate"]))
{
exDateTime2 = ExDateTime.Parse(utcTimeZone, inputrow["EndDate"].ToString());
goto IL_13F;
}
goto IL_13F;
}
}
exDateTime = ExDateTime.Now.AddHours(-48.0);
IL_13F:
inputrow["StartDate"] = (DateTime)exDateTime.ToUtc();
inputrow["EndDate"] = (DateTime)exDateTime2.ToUtc();
}
else
{
inputrow["StartDate"] = DBNull.Value;
inputrow["EndDate"] = DBNull.Value;
}
store.ModifiedColumns.Add("StartDate");
store.ModifiedColumns.Add("EndDate");
}
internal static object GetVariableValue(ICollection <string> modifiedColumns, string variableName, DataRow input, DataTable dataTable, bool isGetListWorkflow)
{
if (modifiedColumns.Contains(variableName))
{
object obj = DDIHelper.ConvertDBNullToNull(input, variableName);
if (obj != null || isGetListWorkflow)
{
return(obj);
}
}
DDIHelper.CheckDataTableForSingleObject(dataTable);
return(DDIHelper.ConvertDBNullToNull(dataTable.Rows[0], variableName));
}
