public CreateController(IBoxPacker packer, IBoxStorage attic, IApiRequest dropbox) { _packer = packer; _attic = attic; _dropbox = dropbox; _mimeTypes = new List<string> { "image/jpeg", "image/png" }; _client = new HttpClient(); //ViewBag.IsMobile = Identity.IsMobile; }
private object GetParameter(Type paraType, IApiRequest request) { object para = null; var reader = new StreamReader(request.InputStream); var body = reader.ReadToEnd(); if (!string.IsNullOrWhiteSpace(body)) { para = JsonConvert.DeserializeObject(body, paraType); } return para; }
public void FireRequestFailureEvent(IApiRequest request, IApiResponse response, RequestFailureReason reason, Action onResume = null, bool foregroundAction = false) { LogUtility.LogMessage(String.Format("firing RequestFailure event (request type:{0}, reason:{1}, callback:{2}, foreground:{3})", (request != null ? request.GetType().Name : "<null>"), Enum.GetName(typeof(RequestFailureReason), reason), (onResume == null ? "no" : "yes"), (foregroundAction ? "yes" : "no"))); if (this._requestFailed != null) { this._requestFailed(this, new RequestFailureEventArgs(request, response, reason, foregroundAction, onResume)); } }
private IApiRequest GenerateVideoDeleteRequest(long clipId) { ThrowIfUnauthorized(); IApiRequest request = ApiRequestFactory.GetApiRequest(AccessToken); request.Method = HttpMethod.Delete; request.Path = Endpoints.Video; request.UrlSegments.Add("clipId", clipId.ToString()); return(request); }
public async Task FireWebhookAndForgetAsync(IApiRequest request, CancellationToken cancelToken = default) { if (request == null) { throw new ArgumentNullException(nameof(request)); } if (!request.IsWebhookRequest) { throw new InvalidOperationException("Only call this for webhook configured requests"); } using var response = await SendRequest(request, HttpCompletionOption.ResponseHeadersRead, cancelToken); }
/// <summary> /// Adds the Query to request. /// </summary> /// <param name="request">The <see cref="IRestRequest" /> request.</param> /// <param name="query">The <see cref="IApiRequest" /> query.</param> protected virtual void AddQuiriesToRequest(ref IRestRequest request, IApiRequest query) { if (query == null) { return; } foreach (var parameter in query.QueryParameters) { request.AddParameter(parameter.Key, parameter.Value, ParameterType.QueryString); } request.AddParameter("apikey", _config.ConsumerKey, ParameterType.QueryString); }
/// <summary> /// Executes the request but limits the number of threads that can be used /// </summary> /// <typeparam name="T"></typeparam> /// <param name="request"></param> /// <returns></returns> public async Task <IApiResponse <T> > EnqueueAsync <T>(IApiRequest request) where T : class { await _throttler.WaitAsync().ConfigureAwait(false); try { return(await _handler.ExecuteAsync <T>(request).ConfigureAwait(false)); } finally { _throttler.Release(); } }
private IApiRequest GenerateAddTagRequest(long clipId, string tag) { ThrowIfUnauthorized(); IApiRequest request = _apiRequestFactory.GetApiRequest(AccessToken); request.Method = Method.PUT; request.Path = Endpoints.VideoTag; request.UrlSegments.Add("clipId", clipId.ToString()); request.UrlSegments.Add("tag", tag); return(request); }
public async Task GetPetsGroupedOnOwnerGender(IApiRequest apiRequest, IPeoplePetRepository peoplePetRepository, List <PetsGroupedOnOwnerGender> expectedResult) { //Arrange IPeoplePetService sut = new PeoplePetservice(peoplePetRepository); //Act List <PetsGroupedOnOwnerGender> result = await sut.getPetsGroupedOnOwnerGender(apiRequest); string resultJson = JsonConvert.SerializeObject(result); string expectedResultJson = JsonConvert.SerializeObject(expectedResult); //Assert Assert.Equal(expectedResultJson, resultJson); }
/*--------------------------------------------------------------------------------------------*/ private static IApiResponse ExecuteAcc(IApiRequest pApiReq, string pGrantType, string pClientId, string pSecret, string pCode, string pRefresh, string pRedirUri) { Func <FabOauthAccess> getResp = (() => { var op = new OauthAccessOperation(); return(op.Execute(pApiReq.OpCtx, new OauthAccessTasks(), pGrantType, pClientId, pSecret, pCode, pRefresh, pRedirUri)); }); var exec = new JsonExecutor <FabOauthAccess>(pApiReq, getResp); exec.OnException = OnAccessExecption; return(exec.Execute()); }
private static CancellationToken GetCancellationTokenForRequest(IApiRequest request, CancellationToken cancellationToken) { var cancellationTokenForRequest = cancellationToken; if (request.Timeout == TimeSpan.Zero) { return(cancellationTokenForRequest); } var timeoutCancellation = new CancellationTokenSource(request.Timeout); var unifiedCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCancellation.Token); cancellationTokenForRequest = unifiedCancellationToken.Token; return(cancellationTokenForRequest); }
/// <summary> /// Sends the specified request and returns a response. /// </summary> /// <param name="request">A <see cref="IApiRequest"/> that represents the HTTP request</param> /// <param name="cancellationToken">Used to cancel the request</param> /// <returns>A <see cref="Task" /> of <see cref="IHttpResponse"/></returns> public async Task <IHttpResponse> GetDataAsync(IApiRequest request, CancellationToken cancellationToken) { Ensure.ArgumentNotNull(nameof(request), request); var cancellationTokenForRequest = GetCancellationTokenForRequest(request, cancellationToken); using (var requestMessage = BuildRequestMessage(request)) { using (var httpResponseMessage = await GetResponseMessageAsync(requestMessage, request, cancellationTokenForRequest)) { return(await BuildResponseAsync(httpResponseMessage).ConfigureAwait(false)); } } }
private IApiRequest AwaitDatastoreChangesRequest(IEnumerable <Datastore> datastores) { JObject args = new JObject(); args["cursors"] = new JObject(); foreach (var store in datastores) { args["cursors"][store.Handle] = store.Rev; } IApiRequest request = ApiRequestFactory.Current.CreateRequest("GET", "await?get_deltas=" + Uri.EscapeDataString(args.ToString(Formatting.None)), ApiToken); return(request); }
/// <summary> /// request handler. retrives a response using the IApiRequest /// </summary> /// <param name="request">request</param> /// <returns>ResponseObject for the given request</returns> public T HandleRequest(IApiRequest request) { // We only want 1 API attempt at a time. // This will prevent two calls from retriving the same data at the same time. lock (_lock) { // First attempt to retrive the ResponseObject response = ResponseCache.Cache.Get(Network.BuildUri(request), IgnoreCache); T apiResponse = null; if (response == null) { Debug.WriteLine(string.Format("Getting {0} from GW2 API", typeof(T).Name)); GwApi.Logger.Debug("Getting {0} from GW2 API", typeof(T).Name); // Response is not cached or has expired var apiResponseObject = Network.GetResponse(request); Debug.WriteLine(string.Format("Parsing {0}", request.Resource)); GwApi.Logger.Debug("Parsing {0}", request.Resource); try { apiResponse = Parser.Parse(apiResponseObject); if (apiResponse != null) { apiResponse.LastUpdated = DateTime.Now; apiResponse.Url = Network.BuildUri(request); apiResponse.SetResponse(apiResponseObject); ResponseCache.Cache.Add(apiResponse); } } catch (ResponseException) { throw; } catch (Exception e) { GwApi.Logger.Error(e); throw; } } else { Debug.WriteLine(string.Format("Getting {0} from cache", typeof(T).Name)); GwApi.Logger.Debug("Getting {0} from cache", typeof(T).Name); } //Debug.WriteLine(response == null ? "Retriving Response using " + Network.GetType() : "Using Cache"); // Return cached response if it's not null // otherwise return the fresh new response return(response as T ?? apiResponse); } }
public static IRestRequest CreateGetRequest(IApiRequest request, string relativePath) { var searchRequest = new RestRequest(relativePath, Method.GET) { RequestFormat = DataFormat.Json }; if (request is IApiGetRequest) { searchRequest.AddParameter("id", (request as IApiGetRequest).Id, ParameterType.UrlSegment); } return(searchRequest); }
public async Task <User> GetUserInformationAsync(long userId) { IApiRequest request = _apiRequestFactory.AuthorizedRequest( AccessToken, Method.GET, Endpoints.User, new Dictionary <string, string>() { { "userId", userId.ToString() } } ); return(await ExecuteApiRequest <User>(request)); }
public async Task <bool> DeleteAlbumAsync(long albumId) { IApiRequest request = _apiRequestFactory.AuthorizedRequest( AccessToken, Method.DELETE, Endpoints.GetCurrentUserEndpoint(Endpoints.UserAlbum), new Dictionary <string, string>() { { "albumId", albumId.ToString() } } ); return(await ExecuteApiRequest(request)); }
private IApiRequest GenerateUserInformationRequest(long?userId = null) { ThrowIfUnauthorized(); IApiRequest request = _apiRequestFactory.GetApiRequest(AccessToken); request.Method = Method.GET; request.Path = userId.HasValue ? Endpoints.User : Endpoints.GetCurrentUserEndpoint(Endpoints.User); if (userId.HasValue) { request.UrlSegments.Add("userId", userId.ToString()); } return(request); }
public static T FabricateLoginFailureResponse <T>(IApiRequest request) where T : IApiResponse, new() { var response = new T(); response.Header = new RequestResponseHeader(ResponseType.Connection, request.Header.Channel, request.Header.SessionId); response.ErrorBody = new ErrorResponseBody() { ResponseMessageShort = StringLiterals.AuthFailure, //"Authentication Failure", ResponseMessageLong = StringLiterals.UserNotAuthenticated, //"User not authenticated.", ErrorType = ErrorResponseType.AuthFailure }; return(response); }
private IApiRequest GenerateVideoAllowedDomainPatchRequest(long clipId, string domain) { ThrowIfUnauthorized(); IApiRequest request = ApiRequestFactory.GetApiRequest(AccessToken); request.Method = HttpMethod.Put; request.Path = Endpoints.VideoAllowedDomain; request.UrlSegments.Add("clipId", clipId.ToString()); request.UrlSegments.Add("domain", domain); return(request); }
public static T FabricateRequestTimeoutResponse <T>(IApiRequest request) where T : IApiResponse, new() { var response = new T(); response.Header = new RequestResponseHeader(ResponseType.TimeoutError, request.Header.Channel, request.Header.SessionId); response.ErrorBody = new ErrorResponseBody() { ResponseMessageShort = "Request Timeout", ResponseMessageLong = String.Format("The {0} request timed out on the client side. Please check your connection.", request.Header.Type), ErrorType = ErrorResponseType.ResponseTimeout }; return(response); }
public static T FabricateConnectionTimeoutResponse <T>(IApiRequest request) where T : IApiResponse, new() { var response = new T(); response.Header = new RequestResponseHeader(request.Header.Type, request.Header.Channel, request.Header.SessionId); response.ErrorBody = new ErrorResponseBody() { ResponseMessageShort = StringLiterals.ConnectionTimeout, //"Connection Timeout", ResponseMessageLong = StringLiterals.UnableToEstablishConnection, //"Unable to establish a connection with the server."), ErrorType = ErrorResponseType.ConnectionTimeout }; return(response); }
public async Task <bool> AddToAlbumAsync(long albumId, long clipId) { IApiRequest request = _apiRequestFactory.AuthorizedRequest( AccessToken, Method.PUT, Endpoints.GetCurrentUserEndpoint(Endpoints.UserAlbumVideo), new Dictionary <string, string>() { { "albumId", albumId.ToString() }, { "clipId", clipId.ToString() } } ); return(await ExecuteApiRequest(request)); }
public async Task <Album> UpdateAlbumAsync(long albumId, EditAlbumParameters parameters = null) { IApiRequest request = _apiRequestFactory.AuthorizedRequest( AccessToken, Method.PATCH, Endpoints.GetCurrentUserEndpoint(Endpoints.UserAlbum), new Dictionary <string, string>() { { "albumId", albumId.ToString() } }, parameters ); return(await ExecuteApiRequest <Album>(request)); }
/// <summary> /// Sends the API request to the REST server and obtains a response asynchronously. /// </summary> /// <param name="restApiRequest">The request to send.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The response from the server.</returns> public virtual async Task <IApiResponse> SendAsync(IApiRequest restApiRequest, CancellationToken cancellationToken) { PrepareForSend(restApiRequest); var client = BuildClient(restApiRequest); var restRequest = BuildRequest(restApiRequest); var restResponse = await client .ExecuteTaskAsync(restRequest, cancellationToken) .ConfigureAwait(false); var apiResponse = BuildResponse(restResponse); return(apiResponse); }
private IApiRequest GenerateDeleteTextTrackRequest(long clipId, long trackId) { ThrowIfUnauthorized(); IApiRequest request = ApiRequestFactory.GetApiRequest(AccessToken); string endpoint = Endpoints.TextTrack; request.Method = Method.DELETE; request.Path = endpoint; request.UrlSegments.Add("clipId", clipId.ToString()); request.UrlSegments.Add("trackId", trackId.ToString()); return(request); }
/*--------------------------------------------------------------------------------------------*/ private static IApiResponse DoRemoveMember(IApiRequest pApiReq) { Func <object> getResp = (() => { var op = new InternalRemoveMemberOperation(); op.Perform(pApiReq.OpCtx, pApiReq.GetQueryValue("pass", false), pApiReq.GetQueryValue("memId", false), pApiReq.GetQueryValue("delete", false)); return(op.GetResult()); }); var exec = new JsonExecutor <object>(pApiReq, getResp); return(exec.Execute()); }
/// <summary> /// Get album by AlbumId asynchronously /// </summary> /// <param name="albumId">AlbumId</param> /// <returns>Album</returns> public async Task <Album> GetAlbumAsync(long albumId) { IApiRequest request = ApiRequestFactory.AuthorizedRequest( AccessToken, Method.GET, Endpoints.GetCurrentUserEndpoint(Endpoints.UserAlbum), new Dictionary <string, string>() { { "albumId", albumId.ToString() } }, null ); return(await ExecuteApiRequest <Album>(request)); }
public string BuildRequest(IApiRequest request) { if (CachedUrls.ContainsKey(request.Type)) { return(BuildFullUrl()); } var url = $"{ _apiConfig.Protocol}://{ _apiConfig.BaseUrl }/{ _apiConfig.Version }/{ _apiConfig.GetRequestPath(request.Type) }?"; CachedUrls.TryAdd(request.Type, url); string BuildFullUrl() => CachedUrls[request.Type] + request.BuildQueryString(); return(BuildFullUrl()); }
public async Task <Paginated <Album> > GetAlbumsAsync(long userId, GetAlbumsParameters parameters = null) { IApiRequest request = _apiRequestFactory.AuthorizedRequest( AccessToken, Method.GET, Endpoints.UserAlbums, new Dictionary <string, string>() { { "userId", userId.ToString() } }, parameters ); return(await ExecuteApiRequest <Paginated <Album> >(request)); }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ private static IApiResponse GetLogout(IApiRequest pApiReq) { Func <FabOauthLogout> getResp = (() => { string token = pApiReq.GetQueryValue(LogoutAccessTokenParam, false); var op = new OauthLogoutOperation(); return(op.Execute(pApiReq.OpCtx, new OauthLogoutTasks(), token)); }); var exec = new JsonExecutor <FabOauthLogout>(pApiReq, getResp); IApiResponse resp = exec.Execute(); resp.SetUserCookie(null, false); return(resp); }
public override Task <IApiResponse> ExecuteAsync(IApiRequest request) { switch (_command.Action) { case SqlCommandAction.LoadModel: return(LoadModelAsync(request)); case SqlCommandAction.UpdateModel: return(UpdateModelAsync(request)); case SqlCommandAction.ExecuteSql: return(ExecuteSqlAsync(request)); } throw new ApiV2Exception($"invalid sql action {_command.Action}"); }
public void ProcessRequest(IApiRequest request, IApiResponse response) { if (string.IsNullOrWhiteSpace(request.Path)) return; ApiPath apiPath; ApiConfig config = ApiConfig.GetInstance(); if (!config.RequestPathCollection.TryGetValue(request.Path, out apiPath)) return; if (apiPath == null) return; var apiInstance = Activator.CreateInstance(apiPath.ServiceType); var method = apiPath.ServiceType.GetMethod(apiPath.Operation); var paraTypes = apiPath.Parameters; List<object> parameters = null; if (paraTypes != null) { parameters = paraTypes.Select(paraType => GetParameter(paraType, request)).ToList(); } var _response = method.Invoke(apiInstance, parameters == null ? null : parameters.ToArray()); if (_response == null) throw new ArgumentNullException("request"); response.Content = _response; response.ContentType = "text/json"; }
public SabNzbdRestRequest(IApiRequest request, ILogger logger) : base(request, logger) { Api = request; Request = new RestRequest { Resource = "api" }; }
public CouchPotatoRestRequest(IApiRequest request, ILogger logger) : base(request, logger) { }
public DropboxController(ITokenStorage storage, IApiRequest dropbox) { _dropbox = dropbox; _storage = storage; }
public RefugeesUnitedAccountManager(IApiRequest apiRequest) { this.apiRequest = apiRequest; }
static void TQServerStatusUpdate(IApiRequest request) { if (request.LastResult != null && request.LastResult.Error == null && request == m_TQServerStatus) { ApiResult<ServerStatus> status = request.LastResult as ApiResult<ServerStatus>; if(OnTQServerUpdate != null) OnTQServerUpdate(status.Result); } }
static void OnRequestUpdated(IApiRequest request) { //Remove requests that are flagged as one shot if (request.RemoveAfterUpdate) m_ApiRequests.Remove(request); }
public PictureController(IResize resize, IBoxStorage attic, IApiRequest dropbox) { _resize = resize; _attic = attic; _dropbox = dropbox; }
public VkApi(IApiRequest ApiRequest, IApiSettingsProvider ApiSettingsProvider) : base(ApiRequest, ApiSettingsProvider) { }
void AccountKeyInfoUpdate(IApiRequest request) { if (request.LastResult != null && request.LastResult.Error == null && request == m_accountKeyInfo) { ApiResult<ApiKeyInfo> keyInfo = request.LastResult as ApiResult<ApiKeyInfo>; KeyAccess = keyInfo.Result.Key.AccessMask; Expires = keyInfo.Result.Key.Expires; foreach (CharacterListItem character in keyInfo.Result.Key.Characters) { AddCharacter(character.CharacterID, character.Name); } OnAccountUpdated(request.LastResult); } }
public PlexRestRequest(IApiRequest request, ILogger logger) : base(request, logger) { Api = request; }
void AccountStatusUpdate(IApiRequest request) { if (request.LastResult != null && request.LastResult.Error == null && request == m_accountStatus) { ApiResult<AccountStatus> accStatus = request.LastResult as ApiResult<AccountStatus>; LogonCount = accStatus.Result.LogonCount; LogonMinutes = accStatus.Result.LogonMinutes; CreateDate = accStatus.Result.CreateDate; PaidUntil = accStatus.Result.PaidUntil; OnAccountUpdated(request.LastResult); } }
protected BaseRequest(IApiRequest request, ILogger logger) { Api = request; Logger = logger; }
public static void AddRequest(IApiRequest request) { request.OnRequestUpdate += new RequestUpdated(OnRequestUpdated); m_ApiRequests.Add(request); }
public SonarrRestRequest(IApiRequest request, ILogger logger) : base(request, logger) { Api = request; }
public NzbGetRestRequest(IApiRequest request, ILogger logger) : base(request, logger) { }
void ApiRequestUpdate(IApiRequest request) { if (request.LastResult != null && request.LastResult.Error == null) { if (request == m_charSheetRequest) { ApiResult<CharacterSheet> charSheet = request.LastResult as ApiResult<CharacterSheet>; UpdateCharacter(charSheet.Result); } else if (request == m_charInfoRequest) { ApiResult<CharacterInfo> charInfo = request.LastResult as ApiResult<CharacterInfo>; UpdateCharacter(charInfo.Result); } else if (request == m_skillQueueRequest) { ApiResult<SkillQueue> queue = request.LastResult as ApiResult<SkillQueue>; SkillQueue = queue.Result; } else if (request == m_AssetListRequest) { ApiResult<AssetList> assets = request.LastResult as ApiResult<AssetList>; // Create asset dictionary keyed on locationID Dictionary<long, List<AssetListInfo>> newAssets = new Dictionary<long, List<AssetListInfo>>(); foreach (API.EVE.AssetListInfo info in assets.Result.Assets) { if (!newAssets.ContainsKey(info.LocationID)) newAssets.Add(info.LocationID, new List<AssetListInfo>()); newAssets[info.LocationID].Add(info); } //TODO: Better - as calling the dictionary itself doesn't trigger a save Assets = newAssets; } else if (request == m_StandingsRequest) { ApiResult<CharacterStandings> standingsResult = request.LastResult as ApiResult<CharacterStandings>; Standings = standingsResult.Result.NPCStandings; } if (!IsUpdating && CharacterUpdated != null) { CharacterUpdated(this, null); } } }