public void Validate(BaseApiRequest baseRequest)
{
// safe to cast here
var request = (SomeDataRequest)baseRequest;
// validate and throw exception if something is wrong
// no reason to validate when we already started processing
}
/// <summary>
/// A general API call for all calls. TResponse can be <typeparamref name="System.Dynamic"/> for
/// dynamic typed.
/// </summary>
public async Task <TResponse> ExecuteGetApiAsync <TResponse>(BaseApiRequest request)
{
var restRequest = this.CreateRequest(request.RestUrl, Method.GET);
var properties = request.GetType().GetProperties();
foreach (var property in properties)
{
var propertyValue = property.GetValue(request);
if (propertyValue != null)
{
var jsonAttribute = property
.GetCustomAttributes(typeof(JsonPropertyAttribute), false)
.FirstOrDefault() as JsonPropertyAttribute;
var name = jsonAttribute == null ? property.Name : jsonAttribute.PropertyName;
restRequest.AddQueryParameter(name, propertyValue.ToString());
}
}
var response = await this.RestClient.ExecuteTaskAsync(restRequest);
response.EnsureStatus(System.Net.HttpStatusCode.OK);
var result = JsonConvert.DeserializeObject <TResponse>(response.Content);
return(result);
}
private static async Task <HttpResponseMessage> GetAsync(string endpoint, BaseApiRequest request)
{
using (var client = Http.GetClient(request))
{
return(await client.GetAsync(endpoint));
}
}
private static HttpResponseMessage Get(string endpoint, BaseApiRequest request)
{
using (var client = Http.GetClient(request))
{
return(client.GetAsync(endpoint).Result);
}
}
private static async Task <HttpResponseMessage> PutAsync(string endpoint, BaseApiRequest request, string content)
{
using (var client = Http.GetClient(request))
{
return(await client.PutAsync(endpoint, new StringContent(content, Encoding.UTF8, "application/json")));
}
}
private static HttpResponseMessage Post(string endpoint, BaseApiRequest request, string content)
{
using (var client = Http.GetClient(request))
{
return(client.PostAsync(endpoint, new StringContent(content, Encoding.UTF8, "application/json")).Result);
}
}
public void Process(BaseApiRequest baseRequest)
{
// safe to cast here
var request = (SomeDataRequest)baseRequest;
// do processing
request.SetResult(1);
}
private static void AppendUser(BaseApiRequest model, ModelBindingContext bindingContext)
{
if (bindingContext.HttpContext.Items.ContainsKey("User"))
{
model.User = (UserDto)bindingContext.HttpContext.Items["User"];
}
model.UserId = model?.User?.UserId ?? 0;
}
public void StartProcessing(BaseApiRequest request)
{
if (_handlers.ContainsKey(request.GetType()))
{
throw new Exception("No handlers registered for request type " + request.GetType());
}
// validate synchronously
_handlers[request.GetType()].Validate(request);
_requests.Add(request);
}
public static async Task <T> PutAsync <T>(string endpoint, BaseApiRequest request, object content) where T : BaseApiResponse, new()
{
var message = await PutAsync(endpoint, request, Convert.SerializeObject(content));
if (Http.IsValidStatusCode(message.StatusCode))
{
return(await Convert.DeserializeMessageAsync <T>(message));
}
throw new ApiException(message);
}
public static async Task <T> GetAsync <T>(string endpoint, BaseApiRequest request = null) where T : BaseApiResponse, new()
{
var message = await GetAsync(endpoint, request);
if (Http.IsValidStatusCode(message.StatusCode))
{
return(await Convert.DeserializeMessageAsync <T>(message));
}
throw new ApiException(message);
}
public static T Get <T>(string endpoint, BaseApiRequest request) where T : BaseApiResponse, new()
{
var message = Get(endpoint, request);
if (Http.IsValidStatusCode(message.StatusCode))
{
return(Convert.DeserializeMessageAsync <T>(message).Result);
}
throw new ApiException(message);
}
public void TestUrlBuilderGenerationWithoutQueryParameters()
{
const string schema = "http";
const string domain = "pr0gramm.com";
const string endpoint = "/api/endpoint";
var request = new BaseApiRequest(schema, domain, endpoint);
var urlResult = Pr0grammUrlBuilder.BuildHttpGetUrl(request);
urlResult.IsSuccess.ShouldBeTrue();
urlResult.Value.ShouldContain(request.ApiDomain);
urlResult.Value.ShouldContain(request.ApiEndpoint);
urlResult.Value.ShouldStartWith(request.ApiScheme);
urlResult.Value.ShouldBe($"{schema}://{domain}{endpoint}");
}
internal static HttpClient GetClient(BaseApiRequest request)
{
// ReSharper disable once UseObjectOrCollectionInitializer
var client = new HttpClient(new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
});
//client.Timeout = TimeSpan.FromSeconds(Settings.Current.Service.Timeout);
client.BaseAddress = new Uri(request.BaseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (!string.IsNullOrWhiteSpace(request?.ApiKey))
{
client.DefaultRequestHeaders.Add("X-Api-Key", request.ApiKey);
}
return(client);
}
//Adds a new call to the API queue to get the users list
public static void GetHelpScoutUserList(UserListViewModel viewModel)
{
userListCallbackHandler = new ViewModelUserListCallback(viewModel.RecieveHelpScoutUserList); //Sets teh delegate for the viewmodel callback
BaseApiRequest<Paged<HelpScoutNet.Model.User>> apiRequest = new BaseApiRequest<Paged<HelpScoutNet.Model.User>>(APICallType.ListUsers);
apiRequest.ResultReady += AcceptHelpScoutUserList;
apiRequest.resultsFailedHandler = new BaseAPIRequest.ResultsFailed(viewModel.FailedToRetrieveHelpScoutUsersList);
HelpScoutRequestManager.NewQueueItem(apiRequest);
}
private static void RecieveTeamOverallStat(object sender, BaseApiRequest<TeamReport>.ResultReadyEventArgs<TeamReport> e)
{
throw new NotImplementedException();
}
public async static Task ListUsers(BaseApiRequest<Paged<HelpScoutNet.Model.User>> request)
{
//logger.Log(LogLevel.Debug, "Attempting To Retrieve HelpScout Users List");
//request.SetResult(client.ListUsers());
Paged<HelpScoutNet.Model.User> result = await client.ListUsers();
request.SetResult(result);
logger.Log(LogLevel.Debug, "Sucessfully Retrieved HelpScout Users List");
}
private void TestCallBack(object sender, BaseApiRequest<Paged<HelpScoutNet.Model.User>>.ResultReadyEventArgs<Paged<HelpScoutNet.Model.User>> e)
{
}
//Recieves the callback from the helpscout queue with the data
private static void AcceptHelpScoutUserList(object sender, BaseApiRequest<Paged<HelpScoutNet.Model.User>>.ResultReadyEventArgs<Paged<HelpScoutNet.Model.User>> e)
{
List<DataTypes.User> usersToReturn = new List<DataTypes.User>();
foreach (HelpScoutNet.Model.User userItem in e.Result.Items)
{
usersToReturn.Add(new HelpScoutMetrics.Model.DataTypes.User() { Name = userItem.FirstName + " " + userItem.LastName, ID = userItem.Id, Valid = true });
}
userListCallbackHandler(usersToReturn);
}
public void SetJwtUidAndRole <T>(BaseApiRequest <T> request) where T : IApiResponse
{
request.JwtUid = Convert.ToInt32(HttpContext.Session.GetString("uid"));
request.JwtRole = HttpContext.Session.GetString("role");
}
