private async Task <List <NotificationTrigger> > GetNotificationTriggersInternalAsync(int objectId, CancellationToken token)
{
var xmlResponse = await RequestEngine.ExecuteRequestAsync(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 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);
}
}
private async Task <string> GetObjectPropertyRawInternalAsync(int objectId, string property, bool text, CancellationToken token)
{
var parameters = new GetObjectPropertyRawParameters(objectId, property, text);
var response = await RequestEngine.ExecuteRequestAsync(
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 <string> GetSensorTargetsResponseAsync(int deviceId, SensorTargetParameters parameters, Func <int, bool> progressCallback)
{
Func <HttpResponseMessage, Task <string> > getSensorTargetTmpId = o => Task.FromResult(ResponseParser.GetSensorTargetTmpId(o));
var tmpIdStr = await RequestEngine.ExecuteRequestAsync(parameters, getSensorTargetTmpId).ConfigureAwait(false);
int tmpId;
if (!int.TryParse(tmpIdStr, out tmpId))
{
throw new PrtgRequestException($"Failed to resolve sensor targets for sensor type '{parameters[Parameter.SensorType]}': type was not valid");
}
var response = await WaitForSensorTargetResolutionAsync(deviceId, tmpId, progressCallback).ConfigureAwait(false);
return(response);
}
/// <summary>
/// Subscribes a person to multiple <see cref="ConvertKitCourse" />s.
/// </summary>
/// <param name="email">The subscriber's email address.</param>
/// <param name="firstName">The subscriber's first name.</param>
/// <param name="courseIds">A list of Course ids to subscribe them to.</param>
/// <returns>The subscriber.</returns>
public async Task <ConvertKitSubscriber> SubscribeToCourses(string email, string firstName, IEnumerable <long> courseIds)
{
long?defaultCourse = courseIds.FirstOrDefault();
if (defaultCourse == null)
{
throw new NullReferenceException("You must specify at least one course id to subscribe to.");
}
var req = RequestEngine.CreateRequest($"Courses/{defaultCourse}/subscribe", Method.POST, "subscription");
if (courseIds.Count() > 1)
{
req.AddQueryParameter("courses", string.Join(",", courseIds.Where(f => f != defaultCourse)));
}
return(await RequestEngine.ExecuteRequestAsync <ConvertKitSubscriber>(_RestClient, req));
}
/// <summary>
/// A method that will throw an exception which looks like { errors: { "order" : [ "some error message" ] } }
/// </summary>
/// <returns></returns>
public async Task ThrowArrayException()
{
var request = RequestEngine.CreateRequest("orders.json", Method.POST);
//Creating an order with tax lines on both line items and the order will return an error
var order = new ShopifyOrder()
{
CreatedAt = DateTime.UtcNow,
LineItems = new List <ShopifyLineItem>()
{
new ShopifyLineItem()
{
Title = "Click Keyboard",
Price = 99.99,
Grams = 600,
Quantity = 1,
TaxLines = new List <ShopifyTaxLine>()
{
new ShopifyTaxLine()
{
Price = 1.0,
Rate = 0.01,
Title = "Keyboard tax"
}
}
}
},
TaxLines = new List <ShopifyTaxLine>()
{
new ShopifyTaxLine()
{
Price = 6.0,
Rate = 0.06,
Title = "State tax"
}
}
};
request.AddJsonBody(new { order });
//Make request
await RequestEngine.ExecuteRequestAsync <ShopifyOrder>(_RestClient, request);
}
internal async Task <List <Channel> > GetChannelsInternalAsync(int sensorId, Func <string, bool> nameFilter = null, Func <int, bool> idFilter = null)
{
if (nameFilter == null)
{
nameFilter = n => true;
}
if (idFilter == null)
{
idFilter = i => true;
}
var response = await RequestEngine.ExecuteRequestAsync(new ChannelParameters(sensorId)).ConfigureAwait(false);
response.Descendants("item").Where(item => item.Element("objid").Value == "-4").Remove();
var items = response.Descendants("item").ToList();
items.Where(e =>
!nameFilter(e.Element("name").Value?.ToString()) ||
!idFilter(Convert.ToInt32(e.Element("objid").Value.ToString()))
).Remove();
items = response.Descendants("item").ToList();
await Task.WhenAll(items.Select(async item =>
{
var id = Convert.ToInt32(item.Element("objid").Value);
var properties = await GetChannelPropertiesAsync(sensorId, id).ConfigureAwait(false);
item.Add(properties.Nodes());
item.Add(new XElement("injected_sensorId", sensorId));
})).ConfigureAwait(false);
if (items.Count > 0)
{
return(XmlDeserializer <Channel> .DeserializeList(response).Items);
}
return(new List <Channel>());
}
private async Task RestartProbeInternalAsync(int[] probeIds, bool waitForRestart, Func <ProbeRestartProgress[], bool> progressCallback, CancellationToken token)
{
var restartTime = waitForRestart ? (DateTime?)(await GetStatusAsync(token).ConfigureAwait(false)).DateTime : null;
if (probeIds != null && probeIds.Length > 1)
{
var tasks = probeIds.Select(probeId => RequestEngine.ExecuteRequestAsync(new RestartProbeParameters(probeId), token: token));
await Task.WhenAll(tasks).ConfigureAwait(false);
}
else
{
RequestEngine.ExecuteRequest(new RestartProbeParameters(probeIds?.Cast <int?>().FirstOrDefault()), token: token);
}
if (waitForRestart)
{
var probe = probeIds == null || probeIds.Length == 0 ? await GetProbesAsync(token).ConfigureAwait(false) : await GetProbesAsync(Property.Id, probeIds, token).ConfigureAwait(false);
await WaitForProbeRestartAsync(restartTime.Value, probe, progressCallback, token).ConfigureAwait(false);
}
}
internal async Task <List <NotificationAction> > GetNotificationActionsInternalAsync(NotificationActionParameters parameters)
{
var response = await RequestEngine.ExecuteRequestAsync(parameters).ConfigureAwait(false);
var items = response.Descendants("item").ToList();
await Task.WhenAll(items.Select(async item =>
{
var id = Convert.ToInt32(item.Element("objid").Value);
var properties = await GetNotificationActionPropertiesAsync(id).ConfigureAwait(false);
item.Add(properties.Nodes());
})).ConfigureAwait(false);
var actions = XmlDeserializer <NotificationAction> .DeserializeList(response).Items;
var actionsWithSchedules = ResponseParser.GroupActionSchedules(actions).ToList();
await UpdateActionSchedulesAsync(actionsWithSchedules).ConfigureAwait(false);
return(actions);
}
internal async Task SetObjectPropertyAsync <T>(BaseSetObjectPropertyParameters <T> parameters, int numObjectIds, CancellationToken token) => await RequestEngine.ExecuteRequestAsync(parameters, m => Task.FromResult <PrtgResponse>(ResponseParser.ParseSetObjectPropertyUrl(numObjectIds, m)), token).ConfigureAwait(false);
private async Task SetNotificationTriggerInternalAsync(TriggerParameters parameters, CancellationToken token)
{
await ValidateTriggerParametersAsync(parameters, token).ConfigureAwait(false);
await RequestEngine.ExecuteRequestAsync(parameters, token : token).ConfigureAwait(false);
}
private async Task <PrtgResponse> GetObjectPropertiesRawInternalAsync(int objectId, object objectType, CancellationToken token) => (await RequestEngine.ExecuteRequestAsync(new GetObjectPropertyParameters(objectId, objectType), token: token).ConfigureAwait(false));
private async Task <XElement> GetChannelPropertiesAsync(int sensorId, int channelId, CancellationToken token)
{
var parameters = new ChannelPropertiesParameters(sensorId, channelId);
return(await RequestEngine.ExecuteRequestAsync(parameters, r => ChannelSettings.GetChannelXml(r, channelId), token).ConfigureAwait(false));
}
public virtual async Task <ShopifyProvince> GetAsync(long countryId, long id)
{
var request = RequestEngine.CreateRequest($"admin/countries/{countryId}/provinces/{id}.json", RestSharp.Method.GET, "province");
return(await RequestEngine.ExecuteRequestAsync <ShopifyProvince>(_RestClient, request));
}
/// <summary>
/// Lists all <see cref="ConvertKitCourse"/>s on the user's account.
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <ConvertKitCourse> > ListAsync()
{
var req = RequestEngine.CreateRequest("courses", Method.GET, "courses");
return(await RequestEngine.ExecuteRequestAsync <List <ConvertKitCourse> >(_RestClient, req));
}
/// <summary>
/// Subscribes a person to a <see cref="ConvertKitCourse"/>.
/// </summary>
/// <param name="email">The subscriber's email address.</param>
/// <param name="firstName">The subscriber's first name.</param>
/// <param name="courseId">The id of the Course to subscribe them to.</param>
/// <returns>The subscriber.</returns>
public async Task <ConvertKitSubscriber> SubscribeToCourse(string email, string firstName, long courseId)
{
var req = RequestEngine.CreateRequest($"courses/{courseId}/subscribe", Method.POST, "subscription");
return(await RequestEngine.ExecuteRequestAsync <ConvertKitSubscriber>(_RestClient, req));
}
/// <summary>
/// Unsubscribes a current <see cref="ConvertKitSubscriber"/>.
/// </summary>
/// <param name="email">The subscriber's email address.</param>
public async Task UnsubscribeAsync(string email)
{
var req = RequestEngine.CreateRequest("subscribers", Method.PUT);
await RequestEngine.ExecuteRequestAsync(_RestClient, req);
}
internal async Task ApproveProbeInternalAsync(int probeId, ProbeApproval action, CancellationToken token) => await RequestEngine.ExecuteRequestAsync(new ApproveProbeParameters(probeId, action)).ConfigureAwait(false);
/// <summary>
/// Updates a <see cref="ConvertKitSubscriber"/>.
/// </summary>
/// <param name="subscriber">The subscriber.</param>
/// <returns>The updated subscriber.</returns>
public async Task <ConvertKitSubscriber> UpdateAsync(long subscriberId, ConvertKitSubscriber subscriber)
{
var req = RequestEngine.CreateRequest($"subscribers/{subscriberId}", Method.PUT, "subscriber");
return(await RequestEngine.ExecuteRequestAsync <ConvertKitSubscriber>(_RestClient, req));
}
