private static void ValidateRequiredValue(PropertyInfo property, NewObjectParameters parameters, DependentPropertyAttribute attrib = null)
{
var val = property.GetValue(parameters);
var dependentStr = attrib != null ? $" when property '{attrib.Property}' is value '{attrib.RequiredValue}'" : "";
if (string.IsNullOrWhiteSpace(val?.ToString()))
{
throw new InvalidOperationException($"Property '{property.Name}' requires a value{dependentStr}, however the value was null, empty or whitespace.");
}
var list = val as IEnumerable;
if (list != null && !(val is string))
{
var casted = list.Cast <object>().ToList();
if (!casted.Any())
{
throw new InvalidOperationException($"Property '{property.Name}' requires a value, however an empty collection was specified.");
}
if (casted.All(c => string.IsNullOrWhiteSpace(c?.ToString())))
{
throw new InvalidOperationException($"Property '{property.Name}' requires a value, however a collection consisting of null, empty or whitespace values was specified.");
}
}
}
internal static SearchFilter[] GetFilters(int destinationId, NewObjectParameters parameters)
{
var filters = new List <SearchFilter>()
{
new SearchFilter(Property.ParentId, destinationId)
};
if (parameters is NewSensorParameters)
{
//When creating new sensors, PRTG may dynamically assign a name based on the sensor's parameters.
//As such, we instead filter for sensors of the newly created type
var sensorType = parameters[Parameter.SensorType];
var str = sensorType is SensorType ? ((Enum)sensorType).EnumToXml() : sensorType?.ToString();
if (!((NewSensorParameters)parameters).DynamicType)
{
filters.Add(new SearchFilter(Property.Type, str?.ToLower() ?? string.Empty));
}
}
else
{
filters.Add(new SearchFilter(Property.Name, parameters.Name));
}
return(filters.ToArray());
}
private void AddObjectInternal(int objectId, NewObjectParameters parameters)
{
var lengthLimit = RequestParser.ValidateObjectParameters(parameters);
var internalParams = RequestParser.GetInternalNewObjectParameters(objectId, parameters);
if (lengthLimit.Count > 0)
{
AddObjectWithExcessiveValue(lengthLimit, internalParams);
}
else
{
RequestEngine.ExecuteRequest(internalParams);
}
}
private async Task AddObjectInternalAsync(int objectId, NewObjectParameters parameters)
{
var lengthLimit = RequestParser.ValidateObjectParameters(parameters);
var internalParams = RequestParser.GetInternalNewObjectParameters(objectId, parameters);
if (lengthLimit.Count > 0)
{
await AddObjectWithExcessiveValueAsync(lengthLimit, internalParams).ConfigureAwait(false);
}
else
{
await RequestEngine.ExecuteRequestAsync(internalParams).ConfigureAwait(false);
}
}
internal List <T> AddAndResolveObject <T>(int destinationId, NewObjectParameters parameters,
Func <SearchFilter[], List <T> > getObjects) where T : SensorOrDeviceOrGroupOrProbe
{
return(AddAndResolveRunner(
() => client.AddObject(
destinationId,
parameters,
getObjects,
true,
DisplayResolutionError,
ShouldStop,
typeof(T) == typeof(Sensor)
)
));
}
internal List <T> AddAndResolveObject <T>(int destinationId, NewObjectParameters parameters,
Func <SearchFilter[], List <T> > getObjects) where T : SensorOrDeviceOrGroupOrProbe
{
return(AddAndResolveRunner(
() => client.AddObject(
new PrtgAPI.Either <IPrtgObject, int>(destinationId),
parameters,
(f, t) => getObjects(f),
true,
CancellationToken,
DisplayResolutionError,
ShouldStop,
typeof(T) == typeof(Sensor)
)
));
}
//######################################
// AddObject
//######################################
internal List <T> AddObject <T>(int parentId, NewObjectParameters parameters,
Func <SearchFilter[], List <T> > getObjects, bool resolve, Action <Type, int> errorCallback = null, Func <bool> shouldStop = null,
bool allowMultiple = false) where T : SensorOrDeviceOrGroupOrProbe
{
if (resolve)
{
var filters = RequestParser.GetFilters(parentId, parameters);
Action addObjectInternal = () => AddObjectInternal(parentId, parameters);
Func <List <T> > getObjs = () => getObjects(filters);
return((ResolveWithDiff(addObjectInternal, getObjs, ResponseParser.ExceptTableObject, errorCallback, shouldStop, allowMultiple)).OrderBy(o => o.Id).ToList());
}
else
{
AddObjectInternal(parentId, parameters);
return(null);
}
}
internal async Task <List <T> > AddObjectAsync <T>(int parentId, NewObjectParameters parameters,
Func <SearchFilter[], Task <List <T> > > getObjects, bool resolve, Action <Type, int> errorCallback = null, Func <bool> shouldStop = null,
bool allowMultiple = false) where T : SensorOrDeviceOrGroupOrProbe
{
if (resolve)
{
var filters = RequestParser.GetFilters(parentId, parameters);
Func <Task> addObjectInternal = async() => await AddObjectInternalAsync(parentId, parameters).ConfigureAwait(false);
Func <Task <List <T> > > getObjs = async() => await getObjects(filters).ConfigureAwait(false);
return((await ResolveWithDiffAsync(addObjectInternal, getObjs, ResponseParser.ExceptTableObject, errorCallback, shouldStop, allowMultiple).ConfigureAwait(false)).OrderBy(o => o.Id).ToList());
}
else
{
await AddObjectInternalAsync(parentId, parameters).ConfigureAwait(false);
return(null);
}
}
private static void ValidateRequiredValue(PropertyInfo property, NewObjectParameters parameters, DependentPropertyAttribute attrib = null)
{
var val = property.GetValue(parameters);
var dependentStr = attrib != null ? $" when property '{attrib.Name}' is value '{attrib.RequiredValue}'" : "";
if (string.IsNullOrEmpty(val?.ToString()))
{
throw new InvalidOperationException($"Property '{property.Name}' requires a value{dependentStr}, however the value was null or empty.");
}
var list = val as IEnumerable;
if (list != null)
{
var casted = list.Cast <object>();
if (!casted.Any())
{
throw new InvalidOperationException($"Property '{property.Name}' requires a value, however an empty list was specified.");
}
}
}
internal static ICommandParameters GetInternalNewObjectParameters(int deviceId, NewObjectParameters parameters)
{
var newParams = new CommandFunctionParameters(parameters.Function);
foreach (var param in parameters.GetParameters())
{
newParams[param.Key] = param.Value;
}
newParams[Parameter.Id] = deviceId;
return(newParams);
}
private static void ValidateDependentProperty(DependentPropertyAttribute attrib, PropertyInfo property, NewObjectParameters parameters)
{
var target = parameters.GetType().GetProperty(attrib.Property.ToString()).GetValue(parameters);
if (target.ToString() == attrib.RequiredValue.ToString())
{
ValidateRequiredValue(property, parameters, attrib);
}
}
internal static List <KeyValuePair <Parameter, object> > ValidateObjectParameters(NewObjectParameters parameters)
{
var propertyCaches = parameters.GetType().GetNormalProperties().ToList();
foreach (var cache in propertyCaches)
{
var requireValue = cache.GetAttribute <RequireValueAttribute>();
if (requireValue != null && requireValue.ValueRequired)
{
ValidateRequiredValue(cache.Property, parameters);
}
var dependency = cache.GetAttribute <DependentPropertyAttribute>();
if (dependency != null)
{
ValidateDependentProperty(dependency, cache.Property, parameters);
}
}
var lengthLimit = parameters.GetParameters().Where(p => p.Key.GetEnumAttribute <LengthLimitAttribute>() != null).ToList();
return(lengthLimit);
}
internal static ICommandParameters GetInternalNewObjectParameters(Either <IPrtgObject, int> deviceOrId, NewObjectParameters parameters)
{
var newParams = new CommandFunctionParameters(parameters.Function);
foreach (var param in parameters.GetParameters())
{
newParams[param.Key] = param.Value;
}
newParams[Parameter.Id] = deviceOrId.GetId();
return(newParams);
}
