/// <summary> /// Provides an enhanced one-time, preprocessing functionality for the cmdlet. /// </summary> protected override void BeginProcessingEx() { if (ParameterSetName == ParameterSet.Default) { //Value is not required, but is required in that we need to explicitly say null if (!MyInvocation.BoundParameters.ContainsKey("Value")) { throw new ParameterBindingException("Value parameter is mandatory, however a value was not specified. If Value should be empty, specify $null"); } ParseValue(); } else if (ParameterSetName == ParameterSet.Dynamic) { dynamicParameters = dynamicParams.GetBoundParameters(this, (p, v) => new PropertyParameter(p, PSObjectUtilities.CleanPSObject(v))).ToArray(); } else if (ParameterSetName == ParameterSet.RawProperty) { RawValue = PSObjectUtilities.CleanPSObject(RawValue); } else if (ParameterSetName == ParameterSet.Raw) { parameters = RawParameters.Keys.Cast <object>() .Select(k => new CustomParameter(k.ToString(), PSObjectUtilities.CleanPSObject(RawParameters[k]), ParameterType.MultiParameter)) .ToArray(); } base.BeginProcessingEx(); }
/// <summary> /// Provides an enhanced one-time, preprocessing functionality for the cmdlet. /// </summary> protected override void BeginProcessingEx() { if (IsNormalParameterSet) { //Value is not required, but is required in that we need to explicitly say null if (!MyInvocation.BoundParameters.ContainsKey("Value")) { throw new ParameterBindingException("Value parameter is mandatory, however a value was not specified. If Value should be empty, specify $null."); } ParseValue(); } else if (IsDynamicParameterSet) { dynamicParameters = dynamicParams.GetBoundParameters(this, (p, v) => new PropertyParameter(p, PSObjectUtilities.CleanPSObject(v))).ToArray(); if (dynamicParameters.Length == 0) { throw new ParameterBindingException($"At least one dynamic property or -{nameof(Property)} and -{nameof(Value)} must be specified."); } } else if (IsRawPropertyParameterSet) { WarnSuspiciousPropertyName(RawProperty); RawValue = PSObjectUtilities.CleanPSObject(RawValue); } else if (IsRawParameterSet) { parameters = RawParameters.Keys.Cast <object>() .Select(k => new CustomParameter(k.ToString(), PSObjectUtilities.CleanPSObject(RawParameters[k]), ParameterType.MultiParameter)) .ToArray(); } base.BeginProcessingEx(); }
private NewSensorParameters CreateRawParameters() { if (!RawParameters.ContainsKey(NameParameter)) { throw new InvalidOperationException($"Hashtable record '{NameParameter}' is mandatory, however a value was not specified"); } if (!RawParameters.ContainsKey(SensorTypeParameter)) { throw new InvalidOperationException($"Hashtable record '{SensorTypeParameter}' is mandatory, however a value was not specified'"); } var parameters = new PSRawSensorParameters(RawParameters[NameParameter]?.ToString(), RawParameters[SensorTypeParameter]?.ToString()); var toAdd = RawParameters.Keys.Cast <object>() .Where(k => k.ToString() != SensorTypeParameter) .Select(k => new CustomParameter(k.ToString(), PSObjectUtilities.CleanPSObject(RawParameters[k]), ParameterType.MultiParameter)) .ToList(); foreach (var param in toAdd) { parameters[param.Name] = param.Value; } if (DynamicType) { parameters.DynamicType = true; } return(parameters); }
public DynamicPropertyTypeParser(Enum property, PropertyCache cache, object value) { Property = property; Value = PSObjectUtilities.CleanPSObject(value); Cache = cache; //Get the PropertyType and ValueType values after unwrapping any nullable types PropertyType = Cache.Property.PropertyType; ValueType = Value?.GetType(); var propertyTypeUnderlying = Nullable.GetUnderlyingType(PropertyType); if (ValueType == null) { if (propertyTypeUnderlying != null) { PropertyType = propertyTypeUnderlying; } } else { //If the property type is nullable, set it to its underlying type. Ideally, we would want to check //that both the property type and value type aren't both nullable, and then set whichever one //was nullable to its underlying type, however since ValueType will be boxed to its underlying //type T, it is never nullable and therefore we don't need to perform this check if (propertyTypeUnderlying != null) { PropertyType = propertyTypeUnderlying; } } }
/// <summary> /// Performs enhanced record-by-record processing functionality for the cmdlet. /// </summary> protected override void ProcessRecordEx() { Value = PSObjectUtilities.CleanPSObject(Value); switch (Trigger.Type) { case TriggerType.Change: SetProperty(new ChangeTriggerParameters(Trigger)); break; case TriggerType.Speed: SetProperty(new SpeedTriggerParameters(Trigger)); break; case TriggerType.State: SetProperty(new StateTriggerParameters(Trigger)); break; case TriggerType.Threshold: SetProperty(new ThresholdTriggerParameters(Trigger)); break; case TriggerType.Volume: SetProperty(new VolumeTriggerParameters(Trigger)); break; default: throw new NotImplementedException($"Handler of trigger type '{Trigger.Type}' is not implemented."); } }
public DynamicPropertyTypeParser(Enum property, PropertyCache cache, object value) { Property = property; Value = PSObjectUtilities.CleanPSObject(value); Cache = cache; GetParameterTypes(); }
/// <summary> /// Stores the value of a property in the underlying set, using its raw serialized name. /// </summary> /// <param name="name">The raw name of the parameter.</param> /// <param name="value">The value to store.</param> protected void SetCustomParameterInternal(string name, object value) { value = PSObjectUtilities.CleanPSObject(value); var parameter = new CustomParameter(name, value); ((ICustomParameterContainer)this).AddParameter(parameter); }
private string FormatSingleParameterInternal(string name, object val, bool encodeValue, bool isEnum = false) { string str = string.Empty; val = PSObjectUtilities.CleanPSObject(val); if (val is string) { str = val.ToString(); } else { if (val is IMultipleSerializable) { var ps = ((IMultipleSerializable)val).GetSerializedFormats().Select(f => FormatSingleParameterInternal(name, f, encodeValue, isEnum) ).ToList(); if (ps.Count > 0) { return(string.Join("&", ps)); } } else if (val is ISerializable) { str = ((ISerializable)val).GetSerializedFormat(); } else if (val is bool) { str = (bool)val ? "1" : "0"; } else { str = Convert.ToString(val); } } if (isEnum && name != Parameter.Password.GetDescription()) { str = str.ToLower(); if (encodeValue) { str = WebUtility.UrlEncode(str); } return($"{name.ToLower()}={str}"); } if (encodeValue) { str = WebUtility.UrlEncode(str); } return($"{name.ToLower()}={str}"); }
/// <summary> /// Gets or sets the value associated with the specified parameter. /// </summary> /// <param name="name">The name of the parameter to get or set.</param> /// <returns>When getting, if the specified parameter exiasts, the value of that parameter. /// If the parameter does not exist, an <see cref="InvalidOperationException"/> will be thrown.</returns> public object this[string name] { get { return(GetIndex(name)); } set { value = PSObjectUtilities.CleanPSObject(value); SetIndex(name, value); } }
/// <summary> /// Provides a one-time, preprocessing functionality for the cmdlet. /// </summary> protected override void BeginProcessing() { First = PSObjectUtilities.CleanPSObject(First); Second = PSObjectUtilities.CleanPSObject(Second); if (ParameterSetName == ParameterSet.Dynamic) { base.BeginProcessing(); } }
/// <summary> /// Provides an enhanced one-time, preprocessing functionality for the cmdlet. /// </summary> protected override void BeginProcessingEx() { Value = PSObjectUtilities.CleanPSObject(Value); if (DynamicSet()) { dynamicParameters = dynamicParams.GetBoundParameters(this, (p, v) => new ChannelParameter(p, PSObjectUtilities.CleanPSObject(v))); } base.BeginProcessingEx(); }
private static SensorQueryTargetParameters GetQueryParameters(Hashtable queryParametersRaw) { if (queryParametersRaw == null) { return(null); } var queryParameters = new SensorQueryTargetParameters(); foreach (var key in queryParametersRaw.Keys.Cast <object>()) { queryParameters[key.ToString()] = PSObjectUtilities.CleanPSObject(queryParametersRaw[key]); } return(queryParameters); }
/// <summary> /// Parse a value into its expected type. Requires the target <paramref name="property"/> contain a Parse method. /// </summary> /// <param name="property">The property the value applies to.</param> /// <param name="value">The value to apply to the property.</param> /// <returns>If the target property type contains a Parse method which did not throw upon being called, the parsed value. Otherwise, the original value.</returns> protected object ParseValueIfRequired(PropertyInfo property, object value) { value = PSObjectUtilities.CleanPSObject(value); //Types that can have possible enum values (such as TriggerChannel) possess a static Parse method for type conversion by the PowerShell runtime. //Only parse types that are defined in the PrtgAPI assembly. if (IsPrtgAPIProperty(property) && !property.PropertyType.IsEnum) { var method = property.PropertyType.GetMethod("Parse", BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static); if (method != null) { try { var newValue = method.Invoke(null, new[] { value }); value = newValue; } catch (Exception) { //Don't care if our value wasn't parsable } } } else { //Try and parse the value if the property type is an Enum or Nullable Enum var type = property.PropertyType; if (!type.IsEnum) { type = Nullable.GetUnderlyingType(property.PropertyType); } if (type?.IsEnum == true) { if (Enum.GetNames(type).Any(e => e.ToLower() == value?.ToString().ToLower())) { return(Enum.Parse(type, value.ToString(), true)); } } } return(value); }
/// <summary> /// Provides an enhanced one-time, preprocessing functionality for the cmdlet. /// </summary> protected override void BeginProcessingEx() { if (this is IDynamicParameters && dynamicParameterSet != null) { dynamicParameters = dynamicParameterSet.GetBoundParameters(this, (p, v) => { var cleaned = PSObjectUtilities.CleanPSObject(v); if (cleaned == null) { return(new List <SearchFilter>()); } var underlying = cleaned.GetType().GetElementType() ?? cleaned.GetType(); if (underlying == typeof(object)) { if (cleaned.IsIEnumerable()) { var first = cleaned.ToIEnumerable().FirstOrDefault(); if (first != null) { underlying = first.GetType(); } } } if (underlying == typeof(string)) { return(GetWildcardFilters(p, cleaned, val => val.ToString())); } if (typeof(IStringEnum).IsAssignableFrom(underlying)) { return(GetWildcardFilters(p, cleaned, val => ((IStringEnum)val).StringValue)); } return(new[] { GetPipelineFilter(p, cleaned) }); }); } base.BeginProcessingEx(); }
/// <summary> /// Formats a <see cref="ParameterType.MultiParameter"/>. Result is in the form name=val1&name=val2&name=val3 /// </summary> /// <param name="enumerable">The values to assign to the parameter</param> /// <param name="description">The serialized name of the parameter</param> /// <returns></returns> private string FormatMultiParameter(IEnumerable enumerable, string description) { var builder = new StringBuilder(); foreach (var e in enumerable) { if (e != null) { var val = PSObjectUtilities.CleanPSObject(e); string query; if (description == Parameter.FilterXyz.GetDescription()) { var filter = (SearchFilter)val; query = FormatMultiParameterFilter(filter, filter.Value); } else if (val != null && val.GetType().IsEnum) //If it's an enum other than FilterXyz { var result = FormatFlagEnum((Enum)val, v => SearchFilter.ToString(description, FilterOperator.Equals, v, null, FilterMode.Normal)); query = result ?? SearchFilter.ToString(description, FilterOperator.Equals, val, null, FilterMode.Normal); } else { query = FormatSingleParameterWithValEncode(description, val); } if (!string.IsNullOrWhiteSpace(query)) { builder.Append(query + "&"); } } } if (builder.Length > 0) { builder.Length--; } return(builder.ToString()); }
internal void BeginProcessing() { Value = PSObjectUtilities.CleanPSObject(Value); if (DynamicSet()) { dynamicParameters = new Lazy <List <TParameter> >(() => { var ret = dynamicParams.GetBoundParameters(cmdlet, (p, v) => createParameter(p, PSObjectUtilities.CleanPSObject(v))); if (ret.Count == 0) { throw new ParameterBindingException($"At least one dynamic property or -{nameof(Property)} and -{nameof(Value)} must be specified."); } return(ret); }); } }
/// <summary> /// Retrieves the value of a <see cref="ParameterType.MultiValue"/> parameter. Result is in the form val1,val2,val3 /// </summary> /// <param name="enumerable">The values to assign to the parameter</param> /// <returns></returns> private string GetMultiValueStr(IEnumerable enumerable) { var builder = new StringBuilder(); foreach (var o in enumerable) { if (o != null) { var obj = PSObjectUtilities.CleanPSObject(o); string toEncode; if (obj != null && obj.GetType().IsEnum) { toEncode = ((Enum)obj).GetDescription(); } else { if (obj is ISerializable) { toEncode = ((ISerializable)obj).GetSerializedFormat(); } else { toEncode = Convert.ToString(obj); } } builder.Append(WebUtility.UrlEncode(toEncode) + ","); } } if (builder.Length > 0) { builder.Length--; } return(builder.ToString().ToLower()); }
/// <summary> /// Performs record-by-record processing functionality for the cmdlet. /// </summary> protected override void ProcessRecord() { if (Value is PSObject) { Value = PSObjectUtilities.CleanPSObject(Value); } FilterMode filterMode = FilterMode.Normal; if (Raw) { filterMode = FilterMode.Raw; } else { if (Illegal) { filterMode = FilterMode.Illegal; } } WriteObject(new SearchFilter(Property, Operator, Value, filterMode)); }
/// <summary> /// Creates nodes for all specified values and <see cref="ScriptBlock"/> results and emits them to the pipeline. /// </summary> /// <param name="values">The values to process.</param> protected void ProcessValues(params TValue[] values) { List <PrtgNode> children = null; if (ScriptBlock != null) { var result = PSObjectUtilities.CleanPSObject(ScriptBlock.Invoke())?.ToIEnumerable().ToArray(); if (result != null) { var invalid = result.Where(v => !(v is PrtgNode)).ToArray(); if (invalid.Length > 0) { throw new InvalidOperationException($"Expected -{nameof(ScriptBlock)} to return one or more values of type '{nameof(PrtgNode)}', however response contained an invalid value of type '{invalid[0].GetType().FullName}'."); } children = result.Cast <PrtgNode>().ToList(); } } ProcessValues(values, children); }
/// <summary> /// Provides an enhanced one-time, preprocessing functionality for the cmdlet. /// </summary> protected override void BeginProcessingEx() { dynamicParameters = dynamicParams.GetBoundParameters(this, (p, v) => new TriggerParameter(p, PSObjectUtilities.CleanPSObject(v))).ToArray(); base.BeginProcessingEx(); }