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)); }