private async Task <List <NotificationTrigger> > GetNotificationTriggersInternalAsync(Either <IPrtgObject, int> objectOrId, CancellationToken token)
{
var xmlResponse = await ObjectEngine.GetObjectsXmlAsync(new NotificationTriggerParameters(objectOrId), token : token).ConfigureAwait(false);
var typed = ResponseParser.ParseNotificationTriggerResponse(objectOrId, xmlResponse);
if (!IsEnglish)
{
var helper = new NotificationTriggerTranslator(typed, objectOrId.GetId());
NotificationTriggerDataTrigger[] raw = null;
int parentId;
while (helper.TranslateTriggers(raw, out parentId))
{
raw = (await GetNotificationTriggerDataAsync(parentId, token).ConfigureAwait(false)).Triggers;
}
}
var updateTriggerChannels = UpdateTriggerChannelsAsync(objectOrId, typed, token);
var updateTriggerActions = UpdateTriggerActionsAsync(typed, token);
await Task.WhenAll(updateTriggerChannels, updateTriggerActions).ConfigureAwait(false);
return(typed);
}
private List <NotificationTrigger> GetNotificationTriggersInternal(Either <IPrtgObject, int> objectOrId, CancellationToken token)
{
var xmlResponse = ObjectEngine.GetObjectsXml(new NotificationTriggerParameters(objectOrId), token: token);
var typed = ResponseParser.ParseNotificationTriggerResponse(objectOrId, xmlResponse);
if (!IsEnglish)
{
var helper = new NotificationTriggerTranslator(typed, objectOrId.GetId());
NotificationTriggerDataTrigger[] raw = null;
int parentId;
while (helper.TranslateTriggers(raw, out parentId))
{
raw = GetNotificationTriggerData(parentId, token).Triggers;
}
}
UpdateTriggerChannels(objectOrId, typed, token);
UpdateTriggerActions(typed, token);
return(typed);
}
internal PrtgClient(string server, string username, string password, AuthMode authMode, IWebClient client,
IXmlSerializer xmlSerializer = null)
{
if (xmlSerializer == null)
{
xmlSerializer = new XmlExpressionSerializer();
}
if (server == null)
{
throw new ArgumentNullException(nameof(server));
}
if (username == null)
{
throw new ArgumentNullException(nameof(username));
}
if (password == null)
{
throw new ArgumentNullException(nameof(password));
}
RequestEngine = new RequestEngine(this, client);
ConnectionDetails = new ConnectionDetails(server, username, password);
Targets = new PrtgTargetHelper(this);
if (authMode == AuthMode.Password)
{
ConnectionDetails.PassHash = GetPassHash(password);
}
ObjectEngine = new ObjectEngine(this, RequestEngine, xmlSerializer);
}
internal Tuple <List <SensorHistoryData>, int> GetSensorHistoryInternal(SensorHistoryParameters parameters)
{
var raw = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, ResponseParser.ValidateSensorHistoryResponse);
var data = ResponseParser.ParseSensorHistoryResponse(raw.Items, parameters.SensorId);
return(Tuple.Create(data, raw.TotalCount));
}
internal Tuple <List <SensorHistoryData>, int> GetSensorHistoryInternal(SensorHistoryParameters parameters)
{
var raw = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, responseParser: m => ResponseParser.GetSensorHistoryResponse(m, LogLevel, RequestEngine.IsDirty));
var data = ResponseParser.ParseSensorHistoryResponse(raw.Items, parameters.SensorId);
return(Tuple.Create(data, raw.TotalCount));
}
private async Task UpdateTriggerActionsAsync(List <NotificationTrigger> triggers, CancellationToken token)
{
var actions = ResponseParser.GroupTriggerActions(triggers);
var parameters = new NotificationActionParameters(actions.Select(a => a.Key).ToArray());
var tasks = actions.Select(g => GetNotificationActionPropertiesAsync(g.Key, token));
var normal = await ObjectEngine.GetObjectsXmlAsync(parameters, token : token).ConfigureAwait(false);
//All the properties of all desired notifications
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
//For each different notification action
for (int i = 0; i < actions.Count; i++)
{
var xDoc = RequestParser.ExtractActionXml(normal, results[i], actions[i].Key);
//Foreach notification action with the same ID
foreach (var action in actions[i])
{
action.LazyXml = new Lazy <XDocument>(() => xDoc);
}
}
var list = ResponseParser.GroupActionSchedules(actions.SelectMany(g => g).ToList()).ToList();
List <Schedule> schedules = new List <Schedule>();
if (list.Count > 0)
{
schedules = await GetSchedulesAsync(Property.Id, list.Select(l => l.Key).ToArray(), token).ConfigureAwait(false);
}
foreach (var group in actions)
{
foreach (var action in group)
{
if (action.lazyScheduleStr != null)
{
var id = PrtgObject.GetId(action.lazyScheduleStr);
if (id != -1)
{
action.schedule = new Lazy <Schedule>(() => schedules.First(s => s.Id == id));
}
else
{
action.schedule = new Lazy <Schedule>(() => new Schedule(action.lazyScheduleStr));
}
}
else
{
action.schedule = new Lazy <Schedule>(() => new Schedule(action.lazyScheduleStr));
}
}
}
}
private IEnumerable <SensorHistoryData> StreamSensorHistoryInternal(SensorHistoryParameters parameters, bool serial)
{
return(ObjectEngine.StreamObjects(
parameters,
serial,
() => GetSensorHistoryTotals(parameters),
p => GetSensorHistoryInternalAsync(p, CancellationToken.None),
GetSensorHistoryInternal
));
}
internal int GetSensorHistoryTotals(SensorHistoryParameters parameters)
{
parameters.Count = 0;
var data = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, ResponseParser.ValidateSensorHistoryResponse);
parameters.GetParameters().Remove(Parameter.Count);
return(Convert.ToInt32(data.TotalCount));
}
internal int GetSensorHistoryTotals(SensorHistoryParameters parameters)
{
parameters.Count = 0;
var data = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, responseParser: m => ResponseParser.GetSensorHistoryResponse(m, LogLevel, RequestEngine.IsDirty));
parameters.GetParameters().Remove(Parameter.Count);
return(Convert.ToInt32(data.TotalCount));
}
private List <NotificationTrigger> GetNotificationTriggersInternal(int objectId, CancellationToken token)
{
var xmlResponse = ObjectEngine.GetObjectsXml(new NotificationTriggerParameters(objectId), token: token);
var parsed = ResponseParser.ParseNotificationTriggerResponse(objectId, xmlResponse);
UpdateTriggerChannels(parsed, token);
UpdateTriggerActions(parsed, token);
return(parsed);
}
internal async Task <List <Schedule> > GetSchedulesInternalAsync(ScheduleParameters parameters)
{
var schedules = await ObjectEngine.GetObjectsAsync <Schedule>(parameters).ConfigureAwait(false);
await Task.WhenAll(schedules.Select(async schedule =>
{
var response = await GetObjectPropertiesRawInternalAsync(schedule.Id, ObjectType.Schedule).ConfigureAwait(false);
ResponseParser.LoadTimeTable(schedule, response);
})).ConfigureAwait(false);
return(schedules);
}
//######################################
// GetSchedulesInternal
//######################################
internal List <Schedule> GetSchedulesInternal(ScheduleParameters parameters)
{
var schedules = ObjectEngine.GetObjects <Schedule>(parameters);
foreach (var schedule in schedules)
{
var response = GetObjectPropertiesRawInternal(schedule.Id, ObjectType.Schedule);
ResponseParser.LoadTimeTable(schedule, response);
}
return(schedules);
}
private string GetObjectPropertyRawInternal(GetObjectPropertyRawParameters parameters, string property)
{
var response = ObjectEngine.GetObjectsXml(
parameters,
responseParser: m => ResponseParser.ParseGetObjectPropertyResponse(
m.Content.ReadAsStringAsync().Result,
property
)
);
return(ResponseParser.ValidateRawObjectProperty(response, parameters));
}
private async Task <string> GetObjectPropertyRawInternalAsync(GetObjectPropertyRawParameters parameters, string property, CancellationToken token)
{
var response = await ObjectEngine.GetObjectsXmlAsync(
parameters,
responseParser : async m => ResponseParser.ParseGetObjectPropertyResponse(
await m.Content.ReadAsStringAsync().ConfigureAwait(false),
property
),
token : token
).ConfigureAwait(false);
return(ResponseParser.ValidateRawObjectProperty(response, parameters));
}
private async Task <List <NotificationTrigger> > GetNotificationTriggersInternalAsync(int objectId, CancellationToken token)
{
var xmlResponse = await ObjectEngine.GetObjectsXmlAsync(new NotificationTriggerParameters(objectId), token : token).ConfigureAwait(false);
var parsed = ResponseParser.ParseNotificationTriggerResponse(objectId, xmlResponse);
var updateTriggerChannels = UpdateTriggerChannelsAsync(parsed, token);
var updateTriggerActions = UpdateTriggerActionsAsync(parsed, token);
await Task.WhenAll(updateTriggerChannels, updateTriggerActions).ConfigureAwait(false);
return(parsed);
}
private async Task <string> WaitForSensorTargetResolutionAsync(int deviceId, int tmpId, Func <int, bool> progressCallback)
{
var parameters = new SensorTargetProgressParameters(deviceId, tmpId);
SensorTargetProgress p;
bool continueQuery = true;
var stopwatch = new Stopwatch();
var timeout = TimeSpan.FromSeconds(60);
stopwatch.Start();
do
{
p = await ObjectEngine.GetObjectAsync <SensorTargetProgress>(parameters).ConfigureAwait(false);
if (progressCallback != null)
{
continueQuery = progressCallback(p.Percent);
}
if (p.Percent < 100)
{
if (!continueQuery)
{
break;
}
if (stopwatch.Elapsed > timeout)
{
throw new TimeoutException("Failed to retrieve sensor information within a reasonable period of time. Check target device is accessible and that valid credentials have been supplied");
}
#if !DEBUG
await Task.Delay(1000).ConfigureAwait(false);
#endif
}
} while (p.Percent < 100);
if (!continueQuery)
{
return(null);
}
ResponseParser.ValidateSensorTargetProgressResult(p);
var page = await RequestEngine.ExecuteRequestAsync(new SensorTargetCompletedParameters(deviceId, tmpId)).ConfigureAwait(false);
return(page);
}
private void UpdateTriggerActions(List <NotificationTrigger> triggers, CancellationToken token)
{
//Group all actions from all triggers together based on their object ID
var actions = ResponseParser.GroupTriggerActions(triggers);
//Retrieve the XML required to construct "proper" notification actions for all unique actions
//specified in the triggers
var actionParameters = new NotificationActionParameters(actions.Select(a => a.Key).ToArray());
var normalActions = new Lazy <XDocument>(() => ObjectEngine.GetObjectsXml(actionParameters, token: token), LazyThreadSafetyMode.PublicationOnly);
foreach (var group in actions)
{
//As soon as a notification with a specified ID is accessed on any one of the triggers, retrieve
//the "supported" properties of ALL of the notification actions, and then retrieve the "unsupported"
//properties of JUST the notification action object ID that was accessed.
var lazyAction = new Lazy <XDocument>(
() => RequestParser.ExtractActionXml(normalActions.Value, GetNotificationActionProperties(group.Key, token), @group.Key),
LazyThreadSafetyMode.PublicationOnly
);
Logger.Log("Setting lazy action to retrieve notification actions");
foreach (var action in group)
{
action.LazyXml = lazyAction;
Logger.Log("Setting lazy action to retrieve notification schedule");
action.schedule = new Lazy <Schedule>(
() =>
{
if (action.lazyScheduleStr != null && PrtgObject.GetId(action.lazyScheduleStr) != -1)
{
Logger.Log($"Resolving schedule {action.lazyScheduleStr} to schedule");
return(GetSchedule(new Schedule(action.lazyScheduleStr).Id, token));
}
return(action.lazyScheduleStr == null ? null : new Schedule(action.lazyScheduleStr));
}, LazyThreadSafetyMode.PublicationOnly);
}
}
}
private NotificationTriggerData GetNotificationTriggerData(Either <IPrtgObject, int> objectOrId, CancellationToken token) =>
ObjectEngine.GetObject <NotificationTriggerData>(
new NotificationTriggerDataParameters(objectOrId),
ParseNotificationTriggerTypes,
token
);
internal async Task <List <SensorHistoryData> > GetSensorHistoryInternalAsync(SensorHistoryParameters parameters, CancellationToken token)
{
var items = await ObjectEngine.GetObjectsAsync <SensorHistoryData>(parameters, responseParser : m => ResponseParser.GetSensorHistoryResponseAsync(m, LogLevel, RequestEngine.IsDirty), token : token).ConfigureAwait(false);
return(ResponseParser.ParseSensorHistoryResponse(items, parameters.SensorId));
}
internal async Task <List <SensorHistoryData> > GetSensorHistoryInternalAsync(SensorHistoryParameters parameters, CancellationToken token)
{
var items = await ObjectEngine.GetObjectsAsync <SensorHistoryData>(parameters, ResponseParser.ValidateSensorHistoryResponse, token : token).ConfigureAwait(false);
return(ResponseParser.ParseSensorHistoryResponse(items, parameters.SensorId));
}
private async Task <NotificationTriggerData> GetNotificationTriggerDataAsync(int objectId, CancellationToken token) =>
await ObjectEngine.GetObjectAsync <NotificationTriggerData>(
new NotificationTriggerDataParameters(objectId),
ParseNotificationTriggerTypesAsync,
token
).ConfigureAwait(false);
private NotificationTriggerData GetNotificationTriggerData(int objectId, CancellationToken token) =>
ObjectEngine.GetObject <NotificationTriggerData>(
new NotificationTriggerDataParameters(objectId),
ParseNotificationTriggerTypes,
token
);
//todo: check all arguments we can in this file and make sure we validate input. when theres a chain of methods, validate on the inner most one except if we pass a parameter object, in which case validate both
/// <summary>
/// Resolves an address to its latitudinal and longitudinal coordinates. May spuriously return no results.
/// </summary>
/// <param name="address">The address to resolve.</param>
/// <returns></returns>
internal List <Location> ResolveAddress(string address) =>
ObjectEngine.GetObject <GeoResult>(new ResolveAddressParameters(address), ResponseParser.ResolveParser).Results.ToList();
/* void InitEngines()
* Init other engines.
*/
private void InitEngines()
{
try
{
this._objEngine = new ObjectEngine();
this._subEngine = new SubEngine();
this._actEngine = new ActionEngine();
this._vpEngine = new VPEngine();
this._logEngine = new LogEngine();
this._exEngine = new ExceptionEngine();
this._isHighlight = this._autoConfig.IsHighlight;
}
catch (TestException)
{
throw;
}
catch (Exception ex)
{
throw new TestFrameworkException("Fatal Error: Can not load engines: " + ex.ToString());
}
}
/// <summary> /// Asynchronously resolves an address to its latitudinal and longitudinal coordinates. May spuriously return no results. /// </summary> /// <param name="address">The address to resolve.</param> /// <param name="token">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> /// <returns></returns> internal async Task <List <Location> > ResolveAddressAsync(string address, CancellationToken token) => (await ObjectEngine.GetObjectAsync <GeoResult>(new ResolveAddressParameters(address), m => Task.FromResult(ResponseParser.ResolveParser(m)), token).ConfigureAwait(false)).Results.ToList();
