/// <summary> /// /// </summary> /// <param name="longpolling">Set true for event notification, false for immediate response.</param> /// <returns></returns> public async Task<Event> GetEventAsync(bool longpolling, ApiVersion version = ApiVersion.V1_0 , CancellationTokenSource cancel = null) { return await Single<Event>( RequestGenerator.Jsonize("getEvent", version, longpolling), CustomParser.AsCameraEvent, cancel).ConfigureAwait(false); }
/// <summary> /// /// </summary> /// <param name="longpolling">Set true for event notification, false for immediate response.</param> /// <returns></returns> public Task<Event> GetEventAsync(bool longpolling, ApiVersion version = ApiVersion.V1_0 , CancellationTokenSource cancel = null) { return Single( RequestGenerator.Jsonize("getEvent", version, longpolling), CustomParser.AsCameraEvent, cancel); }
public BeatRequest(ApiVersion version) { if (version == ApiVersion.Undefined || version == default(ApiVersion)) { throw new AnycmdException("非法的协议版本号" + version.ToName()); } this.Version = version.ToName(); }
public GroupmeApi(ApiVersion version) { string v3Url = ConfigurationManager.AppSettings.Get("V3_Url"); string v2Url = ConfigurationManager.AppSettings.Get("V2_Url"); _v3Client = new RestClient(v3Url); _v2Client = new RestClient(v2Url); _defaultClient = GeClientByVersion(version); _token = ConfigurationManager.AppSettings.Get("token"); }
/// <summary> /// Registers a pair of API version and a <see cref="HttpControllerDescriptor"/> /// </summary> /// <param name="apiVersion"></param> /// <param name="controllerDescriptor"></param> internal void AddVersion(ApiVersion apiVersion, HttpControllerDescriptor controllerDescriptor) { if (apiVersion == null) { throw new ArgumentNullException("apiVersion"); } if (controllerDescriptor == null) { throw new ArgumentNullException("controllerDescriptor"); } try { this._descriptorsPerVersion.Add(apiVersion, controllerDescriptor); } catch (ArgumentException ex) { throw new ArgumentException(ExceptionResources.ApiVersionAlreadyAdded, "apiVersion", ex); } }
private static string ToString(ApiVersion version) { switch (version) { case ApiVersion.V1_0: return "1.0"; case ApiVersion.V1_1: return "1.1"; case ApiVersion.V1_2: return "1.2"; case ApiVersion.V1_3: return "1.3"; default: throw new InvalidOperationException("Version " + version + " is not supported."); } }
public void IsCompatibleTest() { // executing version 3.0.0.0, accepting connections from 2.0.0.0 var av = new ApiVersion(new Version(3, 0, 0, 0), new Version(2, 0, 0, 0)); // server version 1.0.0.0 is not compatible (too old) Assert.IsFalse(av.IsCompatibleWith(new Version(1, 0, 0, 0))); // server version 2.0.0.0 or 3.0.0.0 is compatible Assert.IsTrue(av.IsCompatibleWith(new Version(2, 0, 0, 0))); Assert.IsTrue(av.IsCompatibleWith(new Version(3, 0, 0, 0))); // server version 4.0.0.0 is not compatible (too recent) Assert.IsFalse(av.IsCompatibleWith(new Version(4, 0, 0, 0))); // but can declare it is, indeed, compatible with version 2.0.0.0 or 3.0.0.0 Assert.IsTrue(av.IsCompatibleWith(new Version(4, 0, 0, 0), new Version(2, 0, 0, 0))); Assert.IsTrue(av.IsCompatibleWith(new Version(4, 0, 0, 0), new Version(3, 0, 0, 0))); // but... Assert.IsFalse(av.IsCompatibleWith(new Version(4, 0, 0, 0), new Version(3, 0, 0, 1))); }
private static NGitLab.Impl.Api.ApiVersion VsApiVersionToNgitLabversion(ApiVersion apiVersion) { return((NGitLab.Impl.Api.ApiVersion)Enum.Parse(typeof(NGitLab.Impl.Api.ApiVersion), apiVersion.ToString())); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <returns> /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false. /// </returns> /// <param name="other">An object to compare with this object.</param> public override bool Equals(ApiVersion other) { return other is SemVerApiVersion && ((SemVerApiVersion) other)._version == this._version; }
public User LoginAsync(bool enable2fa, string host, string email, string password, ApiVersion apiVersion) { NGitLab.GitLabClient client = null; User user = null; NGitLab.Impl.Api.ApiVersion _apiVersion = VsApiVersionToNgitLabversion(apiVersion); if (enable2fa) { client = NGitLab.GitLabClient.Connect(host, password, _apiVersion); } else { client = NGitLab.GitLabClient.Connect(host, email, password, _apiVersion); } try { user = client.Users.Current(); user.PrivateToken = client.ApiToken; user.ApiVersion = apiVersion; } catch (WebException ex) { var res = (HttpWebResponse)ex.Response; var statusCode = (int)res.StatusCode; throw ex; } catch (Exception ex1) { throw ex1; } return(user); }
/// <summary> /// Maps the specified OData route and the OData route attributes. /// </summary> /// <param name="configuration">The server configuration.</param> /// <param name="routeName">The name of the route to map.</param> /// <param name="routePrefix">The prefix to add to the OData route's path template.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> associated with the model.</param> /// <param name="configureAction">The configuring action to add the services to the root container.</param> /// <returns>The added <see cref="ODataRoute"/>.</returns> public static ODataRoute MapVersionedODataRoute(this HttpConfiguration configuration, string routeName, string routePrefix, ApiVersion apiVersion, Action <IContainerBuilder> configureAction) { Arg.NotNull(configuration, nameof(configuration)); Arg.NotNull(apiVersion, nameof(apiVersion)); Contract.Ensures(Contract.Result <ODataRoute>() != null); object ConfigureRoutingConventions(IServiceProvider serviceProvider) { var model = serviceProvider.GetRequiredService <IEdmModel>(); var routingConventions = EnsureConventions(ODataRoutingConventions.CreateDefault()); model.SetAnnotationValue(model, new ApiVersionAnnotation(apiVersion)); routingConventions.Insert(0, new VersionedAttributeRoutingConvention(routeName, configuration, apiVersion)); return(routingConventions.ToArray()); } if (!IsNullOrEmpty(routePrefix)) { routePrefix = routePrefix.TrimEnd('/'); } var rootContainer = configuration.CreateODataRootContainer( routeName, builder => { builder.AddService(Singleton, typeof(IEnumerable <IODataRoutingConvention>), ConfigureRoutingConventions); configureAction?.Invoke(builder); }); var pathHandler = rootContainer.GetRequiredService <IODataPathHandler>(); if (pathHandler != null && pathHandler.UrlKeyDelimiter == null) { pathHandler.UrlKeyDelimiter = configuration.GetUrlKeyDelimiter(); } rootContainer.InitializeAttributeRouting(); var routeConstraint = new VersionedODataPathRouteConstraint(routeName, apiVersion); var route = default(ODataRoute); var routes = configuration.Routes; var messageHandler = rootContainer.GetService <HttpMessageHandler>(); if (messageHandler != null) { route = new ODataRoute( routePrefix, routeConstraint, defaults: null, constraints: null, dataTokens: null, handler: messageHandler); } else { var batchHandler = rootContainer.GetService <ODataBatchHandler>(); if (batchHandler != null) { batchHandler.ODataRouteName = routeName; var batchTemplate = IsNullOrEmpty(routePrefix) ? ODataRouteConstants.Batch : routePrefix + '/' + ODataRouteConstants.Batch; routes.MapHttpBatchRoute(routeName + nameof(ODataRouteConstants.Batch), batchTemplate, batchHandler); } route = new ODataRoute(routePrefix, routeConstraint); } routes.Add(routeName, route); AddApiVersionConstraintIfNecessary(route); var unversionedRouteConstraint = new ODataPathRouteConstraint(routeName); var unversionedRoute = new ODataRoute(routePrefix, new UnversionedODataPathRouteConstraint(unversionedRouteConstraint, apiVersion)); AddApiVersionConstraintIfNecessary(unversionedRoute); configuration.Routes.Add(routeName + UnversionedRouteSuffix, unversionedRoute); return(route); }
/// <summary> /// Activates TET C# Client and all underlying routines using default values. Should be called _only_ /// once when an application starts up. Calling thread will be locked during /// initialization. /// </summary> /// <param name="apiVersion"/>Version number of the Tracker API that this client will be compliant to</param> /// <param name="mode"/>Mode though which the client will receive GazeData. Either ClientMode.Push or ClientMode.Pull</param> /// <returns>True is succesfully activated, false otherwise</returns> public bool Activate(ApiVersion apiVersion, ClientMode mode) { return Activate(apiVersion, mode, GazeApiManager.DEFAULT_SERVER_HOST, GazeApiManager.DEFAULT_SERVER_PORT); }
public TwitterApi(string consumerKey, string consumerSecret, string accessToken, string tokenSecret, ApiVersion apiVersion = ApiVersion.V1) : this(consumerKey, consumerSecret, accessToken, tokenSecret, TokenType.AccessToken, apiVersion) { }
static bool ActionIsSatisfiedBy(ActionDescriptor action, ApiVersionModel model, ApiVersion version, ICollection <ActionDescriptor> implicitMatches) { Contract.Requires(action != null); Contract.Requires(implicitMatches != null); if (model == null) { return(false); } if (action.IsMappedTo(version)) { return(true); } if (action.IsImplicitlyMappedTo(version)) { implicitMatches.Add(action); } return(false); }
private RestClient GeClientByVersion(ApiVersion version) { RestClient client; switch (version) { case ApiVersion.V2: client = _v2Client; break; case ApiVersion.V3: client = _v3Client; break; default: throw new ArgumentOutOfRangeException(); } return client; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddCors(); services.AddAuthentication("SystemToken") .AddScheme <SystemTokenAuthenticationHandler.Opts, SystemTokenAuthenticationHandler>("SystemToken", null); services.AddAuthorization(options => { options.AddPolicy("EditSystem", p => p.RequireAuthenticatedUser().AddRequirements(new OwnSystemRequirement())); options.AddPolicy("EditMember", p => p.RequireAuthenticatedUser().AddRequirements(new OwnSystemRequirement())); options.AddPolicy("ViewMembers", p => p.AddRequirements(new PrivacyRequirement <PKSystem>(s => s.MemberListPrivacy))); options.AddPolicy("ViewFront", p => p.AddRequirements(new PrivacyRequirement <PKSystem>(s => s.FrontPrivacy))); options.AddPolicy("ViewFrontHistory", p => p.AddRequirements(new PrivacyRequirement <PKSystem>(s => s.FrontHistoryPrivacy))); }); services.AddSingleton <IAuthenticationHandler, SystemTokenAuthenticationHandler>(); services.AddSingleton <IAuthorizationHandler, MemberOwnerHandler>(); services.AddSingleton <IAuthorizationHandler, SystemOwnerHandler>(); services.AddSingleton <IAuthorizationHandler, SystemPrivacyHandler>(); services.AddControllers() .SetCompatibilityVersion(CompatibilityVersion.Latest) .AddNewtonsoftJson(); // sorry MS, this just does *more* services.AddApiVersioning(c => { c.AssumeDefaultVersionWhenUnspecified = true; c.DefaultApiVersion = ApiVersion.Parse("1.0"); }); services.AddVersionedApiExplorer(c => { c.GroupNameFormat = "'v'VV"; c.DefaultApiVersion = ApiVersion.Parse("1.0"); c.ApiVersionParameterSource = new UrlSegmentApiVersionReader(); c.SubstituteApiVersionInUrl = true; }); services.AddSwaggerGen(c => { c.SwaggerDoc("v1.0", new OpenApiInfo { Title = "PluralKit", Version = "1.0" }); c.EnableAnnotations(); c.AddSecurityDefinition("TokenAuth", new OpenApiSecurityScheme { Name = "Authorization", Type = SecuritySchemeType.ApiKey }); // Exclude routes without a version, then fall back to group name matching (default behavior) c.DocInclusionPredicate((docName, apiDesc) => { if (!apiDesc.RelativePath.StartsWith("v1/")) { return(false); } return(apiDesc.GroupName == docName); }); // Set the comments path for the Swagger JSON and UI. // https://docs.microsoft.com/en-us/aspnet/core/tutorials/getting-started-with-swashbuckle?view=aspnetcore-3.1&tabs=visual-studio#customize-and-extend var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"; var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile); c.IncludeXmlComments(xmlPath); }); services.AddSwaggerGenNewtonsoftSupport(); }
RequestHandler VerifyRequestedApiVersionIsNotAmbiguous(HttpContext httpContext, out ApiVersion apiVersion) { Contract.Requires(httpContext != null); try { apiVersion = httpContext.GetRequestedApiVersion(); } catch (AmbiguousApiVersionException ex) { Logger.LogInformation(ex.Message); apiVersion = default(ApiVersion); return(new BadRequestHandler(Options.ErrorResponses, AmbiguousApiVersion, ex.Message)); } return(null); }
public IntroducedInApiVersionAttribute(ApiVersion version) : base(version) { }
public override OpenApiInfo MakeInfo(ApiVersion version) => new OpenApiInfo { Title = "API", Version = version.ToString("VVVV"), };
/// <summary> /// Determines whether the action should be considered. /// </summary> /// <param name="actionRouteParameterValue">The action route parameter value.</param> /// <param name="actionDescriptor">The associated <see cref="HttpActionDescriptor">action descriptor</see>.</param> /// <param name="route">The associated <see cref="IHttpRoute">route</see>.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> to consider the controller for.</param> /// <returns>True if the action should be explored; otherwise, false.</returns> protected override bool ShouldExploreAction(string actionRouteParameterValue, HttpActionDescriptor actionDescriptor, IHttpRoute route, ApiVersion apiVersion) { Arg.NotNull(actionDescriptor, nameof(actionDescriptor)); Arg.NotNull(route, nameof(route)); Arg.NotNull(apiVersion, nameof(apiVersion)); if (!(route is ODataRoute)) { return(base.ShouldExploreAction(actionRouteParameterValue, actionDescriptor, route, apiVersion)); } if (Options.UseApiExplorerSettings) { var setting = actionDescriptor.GetCustomAttributes <ApiExplorerSettingsAttribute>().FirstOrDefault(); if (setting?.IgnoreApi == true) { return(false); } } return(actionDescriptor.IsMappedTo(apiVersion)); }
public CAdapter(Direct3D direct3D, AdapterInformation adapterInfo) { this.direct3D = direct3D; this.adapterInfo = adapterInfo; desctopDisplayMode = adapterInfo.CurrentDisplayMode; caps = adapterInfo.GetCaps(DeviceType.Hardware); index = adapterInfo.Adapter; var shaderModel = System.Math.Min(caps.VertexShaderVersion.Major, caps.PixelShaderVersion.Major); apiVersion = new ApiVersion(9, (byte)shaderModel); var details = adapterInfo.Details; restrictions = new AdapterRestrictions { UniformBufferSlots = 256, SamplerSlots = caps.MaxSimultaneousTextures, ShaderResourceSlots = caps.MaxSimultaneousTextures, UnorderedAccessResourceSlots = 0, MaxVertexStreams = caps.MaxStreams, MaxVertexStreamElementCount = caps.MaxStreamStride / (4 * sizeof(float)), MaxStreamOutputTargets = 0, MaxViewports = 1, MaxRenderTargets = caps.SimultaneousRTCount, MaxThreadGroupsX = 0, MaxThreadGroupsY = 0, MaxThreadGroupsZ = 0, MaxThreadGroupsTotal = 0, }; adapterDesc = new AdapterDescription { Description = details.Description, VendorId = details.VendorId, DeviceId = details.DeviceId, SubSysId = details.SubsystemId, Revision = details.Revision, DedicatedVideoMemory = 0, DedicatedSystemMemory = 0, SharedSystemMemory = 0, AdapterLuidHigh = 0, AdapterLuidLow = 0, Flags = AdapterFlags.None }; outputDesc = new OutputDescription { DeviceName = details.DeviceName, DesctopCoordinates = new Math.Rectangle(), AttachedToDesctop = false, Rotation = ModeRotation.Unspecified, MonitorHandle = adapterInfo.Monitor }; outputs = new[] { this }; formatSupports = ((Format[])Enum.GetValues(typeof(Format))).ToDictionary(f => f, GetFormatSupport); }
public static void AddVersioning(this IServiceCollection services, string version) { var apiVersion = ApiVersion.Parse(version); AddVersioning(services, apiVersion); }
/// <summary> /// Initializes a new instance of the <see cref="SetService"/> class. /// </summary> /// <param name="serviceAdapter">The service adapter used to interact with the MTG API.</param> /// <param name="version">The version of the API</param> public SetService(IMtgApiServiceAdapter serviceAdapter, ApiVersion version) : base(serviceAdapter, version, ApiEndPoint.Sets) { this._whereQueries = new NameValueCollection(); }
public Activity(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest()) { }
static ODataRoute MapVersionedODataRoute( HttpConfiguration configuration, string routeName, string routePrefix, IEdmModel model, ApiVersion apiVersion, IODataPathHandler pathHandler, IEnumerable <IODataRoutingConvention> routingConventions, ODataBatchHandler batchHandler, HttpMessageHandler defaultHandler) { Arg.NotNull(configuration, nameof(configuration)); Arg.NotNull(model, nameof(model)); Arg.NotNull(apiVersion, nameof(apiVersion)); Contract.Ensures(Contract.Result <ODataRoute>() != null); var routeConventions = EnsureConventions(routingConventions.ToList()); var routes = configuration.Routes; if (!IsNullOrEmpty(routePrefix)) { routePrefix = routePrefix.TrimEnd('/'); } if (pathHandler != null && pathHandler.UrlKeyDelimiter == null) { pathHandler.UrlKeyDelimiter = configuration.GetUrlKeyDelimiter(); } model.SetAnnotationValue(model, new ApiVersionAnnotation(apiVersion)); routeConventions.Insert(0, new VersionedAttributeRoutingConvention(routeName, configuration, apiVersion)); var rootContainer = configuration.CreateODataRootContainer( routeName, builder => builder.AddService(Singleton, typeof(IEdmModel), sp => model) .AddService(Singleton, typeof(IODataPathHandler), sp => pathHandler) .AddService(Singleton, typeof(IEnumerable <IODataRoutingConvention>), sp => routeConventions.ToArray()) .AddService(Singleton, typeof(ODataBatchHandler), sp => batchHandler) .AddService(Singleton, typeof(HttpMessageHandler), sp => defaultHandler)); rootContainer.InitializeAttributeRouting(); var routeConstraint = new VersionedODataPathRouteConstraint(routeName, apiVersion); var route = default(ODataRoute); if (defaultHandler != null) { route = new ODataRoute(routePrefix, routeConstraint, defaults: null, constraints: null, dataTokens: null, handler: defaultHandler); } else { if (batchHandler != null) { batchHandler.ODataRouteName = routeName; var batchTemplate = IsNullOrEmpty(routePrefix) ? ODataRouteConstants.Batch : routePrefix + '/' + ODataRouteConstants.Batch; routes.MapHttpBatchRoute(routeName + nameof(ODataRouteConstants.Batch), batchTemplate, batchHandler); } route = new ODataRoute(routePrefix, routeConstraint); } routes.Add(routeName, route); AddApiVersionConstraintIfNecessary(route); var unversionedRouteConstraint = new ODataPathRouteConstraint(routeName); var unversionedRoute = new ODataRoute(routePrefix, new UnversionedODataPathRouteConstraint(unversionedRouteConstraint, apiVersion)); AddApiVersionConstraintIfNecessary(unversionedRoute); routes.Add(routeName + UnversionedRouteSuffix, unversionedRoute); return(route); }
public IActionResult Get(string accountId, ApiVersion apiVersion) => Ok(new Order(GetType().FullName, accountId, apiVersion.ToString()));
public void OnGazeApiResponse(String response) { var reply = JsonConvert.DeserializeObject<ReplyBase>(response); if (reply.StatusCode == (int)HttpStatusCode.OK) { switch (reply.Category) { case Protocol.CATEGORY_TRACKER: if (reply.Request.Equals(Protocol.TRACKER_REQUEST_GET)) { var jsreader = new JsonTextReader(new StringReader(response)); var json = (JObject)new JsonSerializer().Deserialize(jsreader); JObject values = json[Protocol.KEY_VALUES].ToObject<JObject>(); JToken value; if (null != values) { if (values.TryGetValue(Protocol.TRACKER_VERSION, out value)) version = value.ToObject<ApiVersion>(); if (values.TryGetValue(Protocol.TRACKER_MODE_PUSH, out value)) { if ((bool)value) clientMode = ClientMode.Push; else clientMode = ClientMode.Pull; } if (values.TryGetValue(Protocol.TRACKER_HEARTBEATINTERVAL, out value)) HeartbeatMillis = (int)value; if (values.TryGetValue(Protocol.TRACKER_FRAMERATE, out value)) Framerate = value.ToObject<FrameRate>(); if (values.TryGetValue(Protocol.TRACKER_TRACKERSTATE, out value)) { //if tracker state changed, notify listeners if ((int)value != (int)Trackerstate.GetTypeCode()) { Trackerstate = (TrackerState)(int)value; lock (((ICollection)trackerStateListeners).SyncRoot) { foreach (ITrackerStateListener listener in trackerStateListeners) { try { listener.OnTrackerStateChanged(Trackerstate); } catch (Exception e) { Debug.WriteLine("Exception while calling ITrackerStateListener.OnTrackerStateChanged() on listener " + listener + ": " + e.StackTrace); } } } } } if (values.TryGetValue(Protocol.TRACKER_CALIBRATIONRESULT, out value)) LastCalibrationResult = value.ToObject<CalibrationResult>(); if (values.TryGetValue(Protocol.TRACKER_ISCALIBRATING, out value)) IsCalibrating = (bool)value; if (values.TryGetValue(Protocol.TRACKER_ISCALIBRATED, out value)) { //if calibration state changed, notify listeners if ((bool)value != IsCalibrated) { IsCalibrated = (bool)value; lock (((ICollection)calibrationStateListeners).SyncRoot) { foreach (ICalibrationResultListener listener in calibrationStateListeners) { try { listener.OnCalibrationChanged(IsCalibrated, LastCalibrationResult); } catch (Exception e) { Debug.WriteLine("Exception while calling ICalibrationResultListener.OnCalibrationChanged() on listener " + listener + ": " + e.StackTrace); } } } } } if (values.TryGetValue(Protocol.TRACKER_SCREEN_RESOLUTION_WIDTH, out value)) ScreenResolutionWidth = (int)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_RESOLUTION_HEIGHT, out value)) ScreenResolutionHeight = (int)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_PHYSICAL_WIDTH, out value)) ScreenPhysicalWidth = (int)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_PHYSICAL_HEIGHT, out value)) ScreenPhysicalHeight = (int)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_INDEX, out value)) { //if screen index changed, notify listeners if ((int)value != ScreenIndex) { ScreenIndex = (int)value; lock (((ICollection)trackerStateListeners).SyncRoot) { foreach (ITrackerStateListener listener in trackerStateListeners) { try { listener.OnScreenStatesChanged(ScreenIndex, ScreenResolutionWidth, ScreenResolutionHeight, ScreenPhysicalWidth, ScreenPhysicalHeight); } catch (Exception e) { Debug.WriteLine("Exception while calling ITrackerStateListener.OnScreenStatesChanged() on listener " + listener + ": " + e.StackTrace); } } } } } if (values.TryGetValue(Protocol.TRACKER_FRAME, out value) && null != gazeBroadcaster) { //Add gaze update to high frequency broadcasting queue lock (((ICollection)queueGazeData).SyncRoot) { queueGazeData.Enqueue(value.ToObject<GazeData>()); } events.GetUpdateHandle().Set(); } } //Handle initialization if (initializationLock != null) { lock (initializationLock) { Monitor.Pulse(initializationLock); initializationLock = null; } } } else if (reply.Request.Equals(Protocol.TRACKER_REQUEST_SET)) { //Do nothing } break; case Protocol.CATEGORY_CALIBRATION: switch (reply.Request) { case Protocol.CALIBRATION_REQUEST_START: IsCalibrating = true; if (null != calibrationListener) //Notify calibration listener that a new calibration process was successfully started try { calibrationListener.OnCalibrationStarted(); } catch (Exception e) { Debug.WriteLine("Exception while calling ICalibrationProcessHandler.OnCalibrationStarted() on listener " + calibrationListener + ": " + e.StackTrace); } break; case Protocol.CALIBRATION_REQUEST_POINTSTART: break; case Protocol.CALIBRATION_REQUEST_POINTEND: ++sampledCalibrationPoints; if (null != calibrationListener) { //Notify calibration listener that a new calibration point has been sampled try { calibrationListener.OnCalibrationProgress(sampledCalibrationPoints / totalCalibrationPoints); } catch (Exception e) { Debug.WriteLine("Exception while calling ICalibrationProcessHandler.OnCalibrationProgress() on listener " + calibrationListener + ": " + e.StackTrace); } if (sampledCalibrationPoints == totalCalibrationPoints) //Notify calibration listener that all calibration points have been sampled and the analysis of the calirbation results has begun try { calibrationListener.OnCalibrationProcessing(); } catch (Exception e) { Debug.WriteLine("Exception while calling ICalibrationProcessHandler.OnCalibrationProcessing() on listener " + calibrationListener + ": " + e.StackTrace); } } var cper = JsonConvert.DeserializeObject<CalibrationPointEndReply>(response); if (cper == null || cper.Values.CalibrationResult == null) break; // not done with calibration yet //if calibration state changed, notify listeners if (cper.Values.CalibrationResult.Result != IsCalibrated) { lock (((ICollection)calibrationStateListeners).SyncRoot) { foreach (ICalibrationResultListener listener in calibrationStateListeners) { try { listener.OnCalibrationChanged(cper.Values.CalibrationResult.Result, cper.Values.CalibrationResult); } catch (Exception e) { Debug.WriteLine("Exception while calling ICalibrationStateListener.OnCalibrationChanged() on listener " + listener + ": " + e.StackTrace); } } } } IsCalibrated = cper.Values.CalibrationResult.Result; IsCalibrating = !cper.Values.CalibrationResult.Result; LastCalibrationResult = cper.Values.CalibrationResult; if (null != calibrationListener) { //Notify calibration listener that calibration results are ready for evaluation try { calibrationListener.OnCalibrationResult(cper.Values.CalibrationResult); } catch (Exception e) { Debug.WriteLine("Exception while calling ICalibrationProcessHandler.OnCalibrationResult() on listener " + calibrationListener + ": " + e.StackTrace); } } break; case Protocol.CALIBRATION_REQUEST_ABORT: IsCalibrating = false; //restore states of last calibration if any apiManager.RequestCalibrationStates(); break; case Protocol.CALIBRATION_REQUEST_CLEAR: IsCalibrated = false; IsCalibrating = false; LastCalibrationResult = null; break; } break; // end calibration switch case Protocol.CATEGORY_HEARTBEAT: //do nothing break; default: var rf = JsonConvert.DeserializeObject<ReplyFailed>(response); Debug.WriteLine("Request FAILED"); Debug.WriteLine("Category: " + rf.Category); Debug.WriteLine("Request: " + rf.Request); Debug.WriteLine("StatusCode: " + rf.StatusCode); Debug.WriteLine("StatusMessage: " + rf.Values.StatusMessage); break; } } else { var rf = JsonConvert.DeserializeObject<ReplyFailed>(response); /* * JSON Message status code is different from HttpStatusCode.OK. Check if special TET * specific statuscode before handling error */ switch (rf.StatusCode) { case Protocol.STATUSCODE_CALIBRATION_UPDATE: //The calibration state has changed, clients should update themselves apiManager.RequestCalibrationStates(); break; case Protocol.STATUSCODE_SCREEN_UPDATE: //The primary screen index has changed, clients should update themselves apiManager.RequestScreenStates(); break; case Protocol.STATUSCODE_TRACKER_UPDATE: //The connected Tracker Device has changed state, clients should update themselves apiManager.RequestTrackerState(); break; default: Debug.WriteLine("Request FAILED"); Debug.WriteLine("Category: " + rf.Category); Debug.WriteLine("Request: " + rf.Request); Debug.WriteLine("StatusCode: " + rf.StatusCode); Debug.WriteLine("StatusMessage: " + rf.Values.StatusMessage); break; } } }
/// <summary> /// Returns a value indicating whether the provided action maps to the specified API version. /// </summary> /// <param name="action">The <see cref="ActionDescriptor">action</see> to evaluate.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> to test the mapping for.</param> /// <returns>True if the <paramref name="action"/> explicitly or implicitly maps to the specified /// <paramref name="apiVersion">API version</paramref>; otherwise, false.</returns> public static bool IsMappedTo(this ActionDescriptor action, ApiVersion apiVersion) { Arg.NotNull(action, nameof(action)); return(action.MappingTo(apiVersion) > None); }
/// <summary> /// Maps a versioned OData route. /// </summary> /// <param name="configuration">The extended <see cref="HttpConfiguration">HTTP configuration</see>.</param> /// <param name="routeName">The name of the route to map.</param> /// <param name="routePrefix">The prefix to add to the OData route's path template.</param> /// <param name="model">The <see cref="IEdmModel">EDM model</see> to use for parsing OData paths.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> associated with the model.</param> /// <returns>The mapped <see cref="ODataRoute">OData route</see>.</returns> /// <remarks>The <see cref="ApiVersionAnnotation">API version annotation</see> will be added or updated on the specified <paramref name="model"/> using /// the provided <paramref name="apiVersion">API version</paramref>.</remarks> public static ODataRoute MapVersionedODataRoute(this HttpConfiguration configuration, string routeName, string routePrefix, IEdmModel model, ApiVersion apiVersion) => MapVersionedODataRoute(configuration, routeName, routePrefix, model, apiVersion, new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault(), null, null);
internal UnversionedODataPathRouteConstraint(IRouteConstraint innerConstraint, ApiVersion apiVersion) { Contract.Requires(innerConstraint != null); innerConstraints = new[] { innerConstraint }; this.apiVersion = apiVersion; }
/// <summary> /// Determines whether the specified action should be explored for the indicated API version. /// </summary> /// <param name="actionDescriptor">The <see cref="ActionDescriptor">action</see> to evaluate.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> for action being explored.</param> /// <returns>True if the action should be explored; otherwise, false.</returns> protected virtual bool ShouldExploreAction(ActionDescriptor actionDescriptor, ApiVersion apiVersion) { Arg.NotNull(actionDescriptor, nameof(actionDescriptor)); Arg.NotNull(apiVersion, nameof(actionDescriptor)); var model = actionDescriptor.GetProperty <ApiVersionModel>(); if (model != null) { if (model.IsApiVersionNeutral || model.DeclaredApiVersions.Contains(apiVersion)) { return(true); } if (model.DeclaredApiVersions.Count > 0) { return(false); } } model = actionDescriptor.GetProperty <ControllerModel>()?.GetProperty <ApiVersionModel>(); return(model != null && (model.IsApiVersionNeutral || model.DeclaredApiVersions.Contains(apiVersion))); }
public CAdapter() { var tempWindow = new GameWindow(); GraphicsMode bestMode = tempWindow.Context.GraphicsMode; var tempContext = new Context(tempWindow.Context); var implementation = tempContext.Implementation; apiVersion = new ApiVersion((byte)implementation.MajorVersion, (byte)implementation.MinorVersion); restrictions = new AdapterRestrictions { UniformBufferSlots = tempContext.Implementation.MaxUniformBufferBindings, SamplerSlots = tempContext.Implementation.MaxCombinedTextureImageUnits, // todo Make those separate ShaderResourceSlots = tempContext.Implementation.MaxCombinedTextureImageUnits, UnorderedAccessResourceSlots = 0, // todo Set it MaxVertexStreams = tempContext.Implementation.MaxVertexAttributes, MaxVertexStreamElementCount = 16, // todo: set it MaxStreamOutputTargets = tempContext.Implementation.MaxTransformFeedbackSeparateComponents, // todo: make sure MaxViewports = tempContext.Implementation.MaxViewports, MaxRenderTargets = tempContext.Implementation.MaxColorAttachments, MaxThreadGroupsX = 0, // todo: set it, MaxThreadGroupsY = 0, // todo: set it, MaxThreadGroupsZ = 0, // todo: set it MaxThreadGroupsTotal = 0 }; adapterDesc = new AdapterDescription { Description = GL.GetString(StringName.Renderer), VendorId = 0, DeviceId = 0, SubSysId = 0, Revision = 0, DedicatedVideoMemory = 0, DedicatedSystemMemory = 0, SharedSystemMemory = 0, AdapterLuidHigh = 0, AdapterLuidLow = 0, Flags = AdapterFlags.None }; tempWindow.Dispose(); outputs = GetAvailableDisplays().Select((d, i) => new COutput(d, i)).ToArray(); //foreach (var format in DisplayColorFormats) //{ // var expectedColorFormat = CtObjectGL.ColorFormat(format); // // tempWindow = new GameWindow(1, 1, new GraphicsMode(expectedColorFormat, bestMode.Depth, bestMode.Stencil)); // var actualColorFormat = tempWindow.Context.GraphicsMode.ColorFormat; // tempWindow.Dispose(); // // if (expectedColorFormat.Red == actualColorFormat.Red && // expectedColorFormat.Green == actualColorFormat.Green && // expectedColorFormat.Blue == actualColorFormat.Blue && // expectedColorFormat.Alpha == actualColorFormat.Alpha) // { // supportedDisplayFormats.Add(format); // } //} }
public FeatureLevel(Api api, ApiVersion version) { Api = api; Version = version; }
public static string GetTextForApiVersion(ApiVersion apiVersion) { return Lang.ResourceManager.GetString("ApiVersion_" + apiVersion.ToString(), Lang.Culture); }
protected ActionRequest PrepareViewRequest(string viewCode, Entity oQuery, ApiVersion ver) { if (ver == ApiVersion.V2) { ActionRequest req = new ActionRequest("ext.view.display"); Dictionary<string, object> dictViewQry = new Dictionary<string, object>(); dictViewQry.Add("viewCode", viewCode); req.AddParam("viewQry", dictViewQry); Dictionary<string, object> dictQryCourse = new Dictionary<string, object>(); req.AddParam("qry", oQuery.ToDictionary()); return req; } else if (ver == ApiVersion.V3) { ActionRequest req = new ActionRequest("odv.view.display"); Dictionary<string, object> dictViewQry = new Dictionary<string, object>(); dictViewQry.Add("viewCode", viewCode); req.AddParam("view", dictViewQry); Dictionary<string, object> dictQryCourse = new Dictionary<string, object>(); req.AddParam("qry", oQuery.ToDictionary()); return req; } throw new Exception("未知API版本"); }
/// <summary> /// Activates TET C# Client and all underlying routines using default values. Should be called _only_ /// once when an application starts up. Calling thread will be locked during /// initialization. /// </summary> /// <param name="apiVersion">Version number of the Tracker API that this client will be compliant to</param> /// <param name="mode">Mode though which the client will receive GazeData. Either ClientMode.Push or ClientMode.Pull</param> /// <param name="listener">Listener to notify once the connection to EyeTribe Server has been established</param> /// <returns>True if succesfully activated, false otherwise</returns> public bool Activate(ApiVersion apiVersion, ClientMode mode, IConnectionStateListener listener) { AddConnectionStateListener(listener); return Activate(apiVersion, mode, GazeApiManager.DEFAULT_SERVER_HOST, GazeApiManager.DEFAULT_SERVER_PORT); }
/// <summary> /// Compares the current <see cref="ApiVersion"/> with another object of the same type. The default version does not allow sorting and returns zero. /// </summary> /// <returns> /// A value that indicates the relative order of the objects being compared. The return value has the following meanings: Value Meaning Less than zero This object is less than the <paramref name="other"/> parameter.Zero This object is equal to <paramref name="other"/>. Greater than zero This object is greater than <paramref name="other"/>. /// </returns> /// <param name="other"></param> /// <returns></returns> protected override int CompareToVersion(ApiVersion other) { return this.Version.CompareTo(((SemVerApiVersion) other).Version); }
/// <summary> /// Activates TET C# Client and all underlying routines. Should be called _only_ /// once when an application starts up. Calling thread will be locked during /// initialization. /// </summary> /// <param name="apiVersion">Version number of the Tracker API that this client will be compliant to</param> /// <param name="mode">Mode though which the client will receive GazeData. Either ClientMode.Push or ClientMode.Pull</param> /// <param name="hostname">The host name or IP address where the eye tracking server is running.</param> /// <param name="portnumber">The port number used for the eye tracking server</param> /// <returns>True if succesfully activated, false otherwise</returns> public bool Activate(ApiVersion apiVersion, ClientMode mode, string hostname, int portnumber) { //lock to ensure that state changing method calls are synchronous lock (Instance) { Object threadLock = Thread.CurrentThread; //lock calling thread while initializing lock (threadLock) { //only one entity can initialize at the time lock (initializationLock) { if (!IsActivated) { isInizializing = true; try { //establish connection in seperate thread apiManager = new GazeApiManager(this, this); ThreadPool.QueueUserWorkItem(new WaitCallback(HandleServerConnect), new Object[] { apiManager, mode, apiVersion, hostname, portnumber }); //We wait untill above requests have been handled by server or timeout occurs bool waitSuccess = Monitor.Wait(initializationLock, TimeSpan.FromSeconds(INIT_TIME_DELAY_SECONDS)); if (!waitSuccess) { HandleInitFailure(); Console.Write("Error initializing GazeManager, is EyeTribe Server running?"); } else { //init heartbeat heartbeatHandler = new Heartbeat(apiManager); heartbeatHandler.Start(); isActive = true; //notify connection listeners OnGazeApiConnectionStateChanged(IsActivated); } } catch (Exception e) { HandleInitFailure(); Console.Write("Error initializing GazeManager: " + e.StackTrace); } } return IsActivated; } } } }
public string Get(ApiVersion apiVersion) => $"Controller = {GetType().Name}\nVersion = {apiVersion}";
public async Task <ActionResult <WorkflowDefinition> > Handle([FromBody] SaveWorkflowDefinitionRequest request, [FromRoute] ApiVersion apiVersion, CancellationToken cancellationToken) { var workflowDefinitionId = request.WorkflowDefinitionId; var workflowDefinition = !string.IsNullOrWhiteSpace(workflowDefinitionId) ? await _workflowPublisher.GetDraftAsync(workflowDefinitionId, cancellationToken) : default; var isNew = workflowDefinition == null; if (workflowDefinition == null) { workflowDefinition = _workflowPublisher.New(); if (!string.IsNullOrWhiteSpace(workflowDefinitionId)) { workflowDefinition.DefinitionId = workflowDefinitionId; } } workflowDefinition.Activities = request.Activities; workflowDefinition.Connections = FilterInvalidConnections(request).ToList(); workflowDefinition.Description = request.Description?.Trim(); workflowDefinition.Name = request.Name?.Trim(); workflowDefinition.Variables = request.Variables ?? new Variables(); workflowDefinition.IsSingleton = request.IsSingleton; workflowDefinition.PersistenceBehavior = request.PersistenceBehavior; workflowDefinition.DeleteCompletedInstances = request.DeleteCompletedInstances; workflowDefinition.ContextOptions = request.ContextOptions; workflowDefinition.DisplayName = request.DisplayName?.Trim(); workflowDefinition.Tag = request.Tag?.Trim(); workflowDefinition.Channel = request.Channel?.Trim(); workflowDefinition.TenantId = await _tenantAccessor.GetTenantIdAsync(cancellationToken); if (request.Publish) { workflowDefinition = await _workflowPublisher.PublishAsync(workflowDefinition, cancellationToken); } else { workflowDefinition = await _workflowPublisher.SaveDraftAsync(workflowDefinition, cancellationToken); } return(isNew ? CreatedAtAction("Handle", "GetByVersionId", new { versionId = workflowDefinition.Id, apiVersion = apiVersion.ToString() }, workflowDefinition) : Ok(workflowDefinition)); }
public CAdapter(Adapter1 dxgiAdapter, int index) { this.dxgiAdapter = dxgiAdapter; this.index = index; AdapterDescription1 dxgiDesc = dxgiAdapter.Description1; desc = new AdapterDescription { Description = dxgiDesc.Description, VendorId = dxgiDesc.VendorId, DeviceId = dxgiDesc.DeviceId, SubSysId = dxgiDesc.SubsystemId, Revision = dxgiDesc.Revision, DedicatedVideoMemory = dxgiDesc.DedicatedVideoMemory, DedicatedSystemMemory = dxgiDesc.DedicatedSystemMemory, SharedSystemMemory = dxgiDesc.SharedSystemMemory, AdapterLuidHigh = (int)(dxgiDesc.Luid >> 32), AdapterLuidLow = (int)(dxgiDesc.Luid & 0x00000000FFFFFFFF), Flags = CtBeholder.AdapterFlags(dxgiDesc.Flags) }; outputs = dxgiAdapter.Outputs.Select(o => new COutput(o)).ToArray(); using (var d3dDevice = new Device(dxgiAdapter)) { switch (d3dDevice.FeatureLevel) { case FeatureLevel.Level_9_1: apiVersion = new ApiVersion(9, 1); break; case FeatureLevel.Level_9_3: apiVersion = new ApiVersion(9, 3); break; case FeatureLevel.Level_9_2: apiVersion = new ApiVersion(9, 2); break; case FeatureLevel.Level_10_0: apiVersion = new ApiVersion(10, 0); break; case FeatureLevel.Level_10_1: apiVersion = new ApiVersion(10, 1); break; case FeatureLevel.Level_11_0: apiVersion = new ApiVersion(11, 0); break; default: throw new ArgumentOutOfRangeException("d3dDevice.FeatureLevel"); } restrictions = new AdapterRestrictions { UniformBufferSlots = CommonShaderStage.ConstantBufferApiSlotCount, SamplerSlots = CommonShaderStage.SamplerSlotCount, ShaderResourceSlots = CommonShaderStage.InputResourceSlotCount, UnorderedAccessResourceSlots = ComputeShaderStage.UnorderedAccessViewSlotCount, MaxVertexStreams = InputAssemblerStage.VertexInputResourceSlotCount, MaxVertexStreamElementCount = InputAssemblerStage.VertexInputStructureElementCount, MaxStreamOutputTargets = 4, MaxViewports = 16, MaxRenderTargets = 8, MaxThreadGroupsX = d3dDevice.FeatureLevel == FeatureLevel.Level_11_0 ? ComputeShaderStage.ThreadGroupMaximumX : 768, MaxThreadGroupsY = d3dDevice.FeatureLevel == FeatureLevel.Level_11_0 ? ComputeShaderStage.ThreadGroupMaximumY : 768, MaxThreadGroupsZ = d3dDevice.FeatureLevel == FeatureLevel.Level_11_0 ? ComputeShaderStage.ThreadGroupMaximumZ : 1, MaxThreadGroupsTotal = d3dDevice.FeatureLevel == FeatureLevel.Level_11_0 ? ComputeShaderStage.ThreadGroupMaximumThreadsPerGroup : 768 }; var allFormats = ((ExplicitFormat[])Enum.GetValues(typeof(ExplicitFormat))).Select(x => (Format)x).ToArray(); formatsSupport = allFormats.Select(d3dDevice.CheckFormatSupport).ToArray(); formatInfos = allFormats.Where(f => f != 0).Select(CtBeholder.FormatInfo).ToArray(); //depthStencilFormatInfos = allFormats.Where(f => (formatsSupport[(int)f] & DepthStencilSupportMask) != 0).Select(CtBeholder.DepthStencilFormatInfo).ToArray(); vertexElementFormats = allFormats.Where(f => (formatsSupport[(int)f] & VertexElementSupportMask) != 0).Select(f => (ExplicitFormat)f).ToArray(); multisampleQualityLevels = new int[allFormats.Length, MultisampleCountsToTry.Length]; for (int i = 0; i < allFormats.Length; i++) for (int j = 0; j < MultisampleCountsToTry.Length; j++) multisampleQualityLevels[i, j] = d3dDevice.CheckMultisampleQualityLevels((Format)i, MultisampleCountsToTry[j]); } /* using (var writer = new System.IO.StreamWriter("Formats.txt")) { for (int i = 0; i < formatsSupport.Length; i++) { writer.WriteLine(string.Format("{0, -30}:{1}", (Format)i, formatsSupport[i].ToString().Replace(", ", " | "))); } }*/ }
/// <summary> /// Initializes a new instance of the <see cref="CardService"/> class. /// </summary> /// <param name="serviceAdapter">The service adapter used to interact with the MTG API.</param> /// <param name="version">The version of the API</param> /// <param name="rateLimitOn">Turn the rate limit on or off.</param> public CardService(IMtgApiServiceAdapter serviceAdapter, ApiVersion version, bool rateLimitOn = true) : base(serviceAdapter, version, ApiEndPoint.Cards, rateLimitOn) { _whereQueries = new NameValueCollection(); }
internal void HandleApiResponse(Object stateInfo) { try { String response = (String)stateInfo; var reply = JsonConvert.DeserializeObject<ReplyBase>(response); if (reply.StatusCode == (int)HttpStatusCode.OK) { switch (reply.Category) { case Protocol.CATEGORY_TRACKER: if (reply.Request.Equals(Protocol.TRACKER_REQUEST_GET)) { var jsreader = new JsonTextReader(new StringReader(response)); var json = (JObject)new JsonSerializer().Deserialize(jsreader); JObject values = null != json[Protocol.KEY_VALUES] ? json[Protocol.KEY_VALUES].ToObject<JObject>() : null; JToken value; if (null != values) { if (values.TryGetValue(Protocol.TRACKER_VERSION, out value)) version = value.ToObject<ApiVersion>(); if (values.TryGetValue(Protocol.TRACKER_MODE_PUSH, out value)) { if ((bool)value) clientMode = ClientMode.Push; else clientMode = ClientMode.Pull; } if (values.TryGetValue(Protocol.TRACKER_HEARTBEATINTERVAL, out value)) HeartbeatMillis = (int)value; if (values.TryGetValue(Protocol.TRACKER_FRAMERATE, out value)) Framerate = value.ToObject<FrameRate>(); if (values.TryGetValue(Protocol.TRACKER_TRACKERSTATE, out value)) { //if tracker state changed, notify listeners if ((int)value != (int)Convert.ChangeType(Trackerstate, Trackerstate.GetTypeCode())) { Trackerstate = (TrackerState)(int)value; foreach (ITrackerStateListener listener in trackerStateListeners) { ThreadPool.QueueUserWorkItem(new WaitCallback(HandleOnTrackerStateChanged), new Object[] { listener, Trackerstate }); } } } if (values.TryGetValue(Protocol.TRACKER_ISCALIBRATING, out value)) IsCalibrating = (bool)value; if (values.TryGetValue(Protocol.TRACKER_ISCALIBRATED, out value)) IsCalibrated = (bool)value; if (values.TryGetValue(Protocol.TRACKER_CALIBRATIONRESULT, out value)) { //is result different from current? if (null == LastCalibrationResult || !LastCalibrationResult.Equals(value.ToObject<CalibrationResult>())) { LastCalibrationResult = value.ToObject<CalibrationResult>(); foreach (ICalibrationResultListener listener in calibrationResultListeners) { ThreadPool.QueueUserWorkItem(new WaitCallback(HandleOnCalibrationChanged), new Object[] { listener, IsCalibrated, LastCalibrationResult }); } } } if (values.TryGetValue(Protocol.TRACKER_SCREEN_RESOLUTION_WIDTH, out value)) ScreenResolutionWidth = (int)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_RESOLUTION_HEIGHT, out value)) ScreenResolutionHeight = (int)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_PHYSICAL_WIDTH, out value)) ScreenPhysicalWidth = (float)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_PHYSICAL_HEIGHT, out value)) ScreenPhysicalHeight = (float)value; if (values.TryGetValue(Protocol.TRACKER_SCREEN_INDEX, out value)) { //if screen index changed, notify listeners if ((int)value != ScreenIndex) { ScreenIndex = (int)value; foreach (ITrackerStateListener listener in trackerStateListeners) { ThreadPool.QueueUserWorkItem(new WaitCallback(HandleOnScreenStatesChanged), new Object[] { listener, ScreenIndex, ScreenResolutionWidth, ScreenResolutionHeight, ScreenPhysicalWidth, ScreenPhysicalHeight }); } } } if (values.TryGetValue(Protocol.TRACKER_FRAME, out value) && null != gazeBroadcaster) { GazeData gd = value.ToObject<GazeData>(); //fixing timestamp based on string representation, Json 32bit int issue if (!String.IsNullOrEmpty(gd.TimeStampString)) { try { DateTime gdTime = DateTime.ParseExact(gd.TimeStampString, GazeData.TIMESTAMP_STRING_FORMAT, System.Globalization.CultureInfo.InvariantCulture); gd.TimeStamp = (long)((double)gdTime.Ticks / TimeSpan.TicksPerMillisecond); } catch (Exception e) { //consume possible error } } //Add gaze update to high frequency broadcasting queue gazeQueue.Put(gd); } } //Handle initialization if (isInizializing) { //we make sure response is inital get request and not a 'push mode' frame if (!values.TryGetValue(Protocol.TRACKER_FRAME, out value)) { lock (initializationLock) { isInizializing = false; Monitor.Pulse(initializationLock); } } } } else if (reply.Request.Equals(Protocol.TRACKER_REQUEST_SET)) { //Do nothing } break; case Protocol.CATEGORY_CALIBRATION: switch (reply.Request) { case Protocol.CALIBRATION_REQUEST_START: IsCalibrating = true; if (null != calibrationListener) //Notify calibration listener that a new calibration process was successfully started try { calibrationListener.OnCalibrationStarted(); } catch (Exception e) { Console.Write("Exception while calling ICalibrationProcessHandler.OnCalibrationStarted() on listener " + calibrationListener + ": " + e.StackTrace); } break; case Protocol.CALIBRATION_REQUEST_POINTSTART: break; case Protocol.CALIBRATION_REQUEST_POINTEND: ++sampledCalibrationPoints; if (null != calibrationListener) { //Notify calibration listener that a new calibration point has been sampled try { calibrationListener.OnCalibrationProgress((double)sampledCalibrationPoints / totalCalibrationPoints); } catch (Exception e) { Console.Write("Exception while calling ICalibrationProcessHandler.OnCalibrationProgress() on listener " + calibrationListener + ": " + e.StackTrace); } if (sampledCalibrationPoints == totalCalibrationPoints) //Notify calibration listener that all calibration points have been sampled and the analysis of the calirbation results has begun try { calibrationListener.OnCalibrationProcessing(); } catch (Exception e) { Console.Write("Exception while calling ICalibrationProcessHandler.OnCalibrationProcessing() on listener " + calibrationListener + ": " + e.StackTrace); } } var cper = JsonConvert.DeserializeObject<CalibrationPointEndReply>(response); if (cper == null || cper.Values.CalibrationResult == null) break; // not done with calibration yet IsCalibrated = cper.Values.CalibrationResult.Result; IsCalibrating = !cper.Values.CalibrationResult.Result; // Evaluate resample points sampledCalibrationPoints -= cper.Values.CalibrationResult.Calibpoints.Where(cp => cp.State == CalibrationPoint.STATE_RESAMPLE || cp.State == CalibrationPoint.STATE_NO_DATA).Count(); // Notify calibration result listeners if calibration changed if (IsCalibrated && (null == LastCalibrationResult || !LastCalibrationResult.Equals(cper.Values.CalibrationResult))) { LastCalibrationResult = cper.Values.CalibrationResult; foreach (ICalibrationResultListener listener in calibrationResultListeners) { ThreadPool.QueueUserWorkItem(new WaitCallback(HandleOnCalibrationChanged), new Object[] { listener, IsCalibrated, LastCalibrationResult }); } } if (null != calibrationListener) { // Notify calibration listener that calibration results are ready for evaluation try { calibrationListener.OnCalibrationResult(cper.Values.CalibrationResult); } catch (Exception e) { Console.Write("Exception while calling ICalibrationProcessHandler.OnCalibrationResult() on listener " + calibrationListener + ": " + e.StackTrace); } } break; case Protocol.CALIBRATION_REQUEST_ABORT: IsCalibrating = false; //restore states of last calibration if any apiManager.RequestCalibrationStates(); break; case Protocol.CALIBRATION_REQUEST_CLEAR: IsCalibrated = false; IsCalibrating = false; LastCalibrationResult = null; break; } break; // end calibration switch case Protocol.CATEGORY_HEARTBEAT: //do nothing break; default: var rf = JsonConvert.DeserializeObject<ReplyFailed>(response); Debug.WriteLine("Request FAILED"); Debug.WriteLine("Category: " + rf.Category); Debug.WriteLine("Request: " + rf.Request); Debug.WriteLine("StatusCode: " + rf.StatusCode); Debug.WriteLine("StatusMessage: " + rf.Values.StatusMessage); break; } } else { var rf = JsonConvert.DeserializeObject<ReplyFailed>(response); /* * JSON Message status code is different from HttpStatusCode.OK. Check if special TET * specific statuscode before handling error */ switch (rf.StatusCode) { case Protocol.STATUSCODE_CALIBRATION_UPDATE: //The calibration state has changed, clients should update themselves apiManager.RequestCalibrationStates(); break; case Protocol.STATUSCODE_SCREEN_UPDATE: //The primary screen index has changed, clients should update themselves apiManager.RequestScreenStates(); break; case Protocol.STATUSCODE_TRACKER_UPDATE: //The connected Tracker Device has changed state, clients should update themselves apiManager.RequestTrackerState(); break; default: Debug.WriteLine("Request FAILED"); Debug.WriteLine("Category: " + rf.Category); Debug.WriteLine("Request: " + rf.Request); Debug.WriteLine("StatusCode: " + rf.StatusCode); Debug.WriteLine("StatusMessage: " + rf.Values.StatusMessage); break; } } } catch (Exception e) { Debug.WriteLine("Exception while parsing API response: " + e.StackTrace); } }
public KeyValuePair <int, string> GeneralRequest(string url, string method, string payload = null, ApiVersion api = ApiVersion.V5, string clientId = null, string accessToken = null) { var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = new HttpMethod(method) }; if (string.IsNullOrEmpty(clientId) && string.IsNullOrEmpty(accessToken)) { throw new InvalidCredentialException("A Client-Id or OAuth token is required to use the Twitch API. If you previously set them in InitializeAsync, please be sure to await the method."); } if (!string.IsNullOrEmpty(clientId)) { request.Headers.Add("Client-ID", clientId); } var authPrefix = "OAuth"; if (api == ApiVersion.Helix) { request.Headers.Add(HttpRequestHeader.Accept.ToString(), "application/json"); authPrefix = "Bearer"; } else if (api != ApiVersion.Void) { request.Headers.Add(HttpRequestHeader.Accept.ToString(), $"application/vnd.twitchtv.v{(int)api}+json"); } if (!string.IsNullOrEmpty(accessToken)) { request.Headers.Add(HttpRequestHeader.Authorization.ToString(), $"{authPrefix} {Common.Helpers.FormatOAuth(accessToken)}"); } if (payload != null) { request.Content = new StringContent(payload, Encoding.UTF8, "application/json"); } var response = _http.SendAsync(request).GetAwaiter().GetResult(); if (response.IsSuccessStatusCode) { var respStr = response.Content.ReadAsStringAsync().GetAwaiter().GetResult(); return(new KeyValuePair <int, string>((int)response.StatusCode, respStr)); } HandleWebException(response); return(new KeyValuePair <int, string>(0, null)); }
/// <summary> /// Activates TET C# Client and all underlying routines. Should be called _only_ /// once when an application starts up. Calling thread will be locked during /// initialization. /// </summary> /// <param name="apiVersion">Version number of the Tracker API that this client will be compliant to</param> /// <param name="mode">Mode though which the client will receive GazeData. Either ClientMode.Push or ClientMode.Pull</param> /// <param name="hostname">The host name or IP address where the eye tracking server is running.</param> /// <param name="portnumber">The port number used for the eye tracking server</param> /// <param name="listener">Listener to notify once the connection to EyeTribe Server has been established</param> /// <returns>True if succesfully activated, false otherwise</returns> public bool Activate(ApiVersion apiVersion, ClientMode mode, string hostname, int portnumber, IConnectionStateListener listener) { AddConnectionStateListener(listener); return Activate(apiVersion, mode, hostname, portnumber, listener); }
/// <summary> /// Determines whether the controller should be considered. /// </summary> /// <param name="controllerRouteParameterValue">The controller route parameter value.</param> /// <param name="controllerDescriptor">The associated <see cref="HttpControllerDescriptor">controller descriptor</see>.</param> /// <param name="route">The associated <see cref="IHttpRoute">route</see>.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> to consider the controller for.</param> /// <returns>True if the controller should be explored; otherwise, false.</returns> protected override bool ShouldExploreController(string controllerRouteParameterValue, HttpControllerDescriptor controllerDescriptor, IHttpRoute route, ApiVersion apiVersion) { Arg.NotNull(controllerDescriptor, nameof(controllerDescriptor)); Arg.NotNull(route, nameof(route)); Arg.NotNull(apiVersion, nameof(apiVersion)); if (typeof(MetadataController).IsAssignableFrom(controllerDescriptor.ControllerType)) { return(false); } var routeTemplate = route.RouteTemplate; if (!odataVariableRegex.IsMatch(routeTemplate)) { return(base.ShouldExploreController(controllerRouteParameterValue, controllerDescriptor, route, apiVersion)); } if (Options.UseApiExplorerSettings) { var setting = controllerDescriptor.GetCustomAttributes <ApiExplorerSettingsAttribute>().FirstOrDefault(); if (setting?.IgnoreApi == true) { return(false); } } var model = controllerDescriptor.GetApiVersionModel(); return(model.IsApiVersionNeutral || model.DeclaredApiVersions.Contains(apiVersion)); }
/// <summary> /// Constructor /// </summary> /// <param name="gatewayUri"></param> /// <param name="version"></param> public FdGatewayManager(string gatewayUri, ApiVersion version) { GatewayUri = gatewayUri; Version = version; }
/// <summary> /// Explores controllers that do not use direct routes (aka "attribute" routing) /// </summary> /// <param name="controllerMappings">The <see cref="IDictionary{TKey, TValue}">collection</see> of controller mappings.</param> /// <param name="route">The <see cref="IHttpRoute">route</see> to explore.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> to explore.</param> /// <returns>The <see cref="Collection{T}">collection</see> of discovered <see cref="VersionedApiDescription">API descriptions</see>.</returns> protected override Collection <VersionedApiDescription> ExploreRouteControllers(IDictionary <string, HttpControllerDescriptor> controllerMappings, IHttpRoute route, ApiVersion apiVersion) { if (!(route is ODataRoute)) { return(base.ExploreRouteControllers(controllerMappings, route, apiVersion)); } var apiDescriptions = new Collection <VersionedApiDescription>(); var edmModel = Configuration.GetODataRootContainer(route).GetRequiredService <IEdmModel>(); var routeApiVersion = edmModel.GetAnnotationValue <ApiVersionAnnotation>(edmModel)?.ApiVersion; if (routeApiVersion != apiVersion) { return(apiDescriptions); } var actionSelector = Configuration.Services.GetActionSelector(); foreach (var controllerMapping in controllerMappings) { var controllerVariableValue = controllerMapping.Key; foreach (var controllerDescriptor in controllerMapping.Value.AsEnumerable()) { if (ShouldExploreController(controllerVariableValue, controllerDescriptor, route, apiVersion)) { ExploreRouteActions(route, controllerDescriptor, actionSelector, apiDescriptions, apiVersion); } } } return(apiDescriptions); }
private RestResponse SendJsonRequest(string resource, Method method, object body = null, Dictionary<string, object> parameters = null, ApiVersion? version = null) { var request = new RestRequest(resource, method) { RequestFormat = DataFormat.Json }; request.AddHeader("X-Access-Token", _token); if (body != null) request.AddBody(body); if (parameters != null && parameters.Count > 0) { foreach (KeyValuePair<string, object> parameter in parameters) { request.AddParameter(parameter.Key, parameter.Value); } } RestClient client = version.HasValue ? GeClientByVersion(version.Value) : _defaultClient; var response = (RestResponse)client.Execute(request); return response; }
/// <summary> /// Determines whether the action should be considered. /// </summary> /// <param name="actionRouteParameterValue">The action route parameter value.</param> /// <param name="actionDescriptor">The associated <see cref="HttpActionDescriptor">action descriptor</see>.</param> /// <param name="route">The associated <see cref="IHttpRoute">route</see>.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> to consider the controller for.</param> /// <returns>True if the action should be explored; otherwise, false.</returns> protected override bool ShouldExploreAction(string actionRouteParameterValue, HttpActionDescriptor actionDescriptor, IHttpRoute route, ApiVersion apiVersion) { Arg.NotNull(actionDescriptor, nameof(actionDescriptor)); Arg.NotNull(route, nameof(route)); Arg.NotNull(apiVersion, nameof(apiVersion)); if (!(route is ODataRoute)) { return(base.ShouldExploreAction(actionRouteParameterValue, actionDescriptor, route, apiVersion)); } if (Options.UseApiExplorerSettings) { var setting = actionDescriptor.GetCustomAttributes <ApiExplorerSettingsAttribute>().FirstOrDefault(); if (setting?.IgnoreApi == true) { return(false); } } var model = actionDescriptor.GetApiVersionModel(); if (model.IsApiVersionNeutral || model.DeclaredApiVersions.Contains(apiVersion)) { return(true); } if (model.DeclaredApiVersions.Count == 0) { model = actionDescriptor.ControllerDescriptor.GetApiVersionModel(); return(model.IsApiVersionNeutral || model.DeclaredApiVersions.Contains(apiVersion)); } return(false); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <returns> /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false. /// </returns> /// <param name="other">An object to compare with this object.</param> public override bool Equals(ApiVersion other) { return ReferenceEquals(other, this); }
public void Apply(ODataModelBuilder builder, ApiVersion apiVersion, string?routePrefix) { builder.EntitySet <GreetingEntity>("Greetings").EntityType .HasKey(_ => _.Message) .Select().Count(); }
/// <summary> /// Activates TET C# Client and all underlying routines. Should be called _only_ /// once when an application starts up. Calling thread will be locked during /// initialization. /// </summary> /// <param name="apiVersion"/>Version number of the Tracker API that this client will be compliant to</param> /// <param name="mode"/>Mode though which the client will receive GazeData. Either ClientMode.Push or ClientMode.Pull</param> /// <param name="hostname"/>The host name or IP address where the eye tracking server is running.</param> /// <param name="portnumber"/>The port number used for the eye tracking server</param> /// <returns>True is succesfully activated, false otherwise</returns> public bool Activate(ApiVersion apiVersion, ClientMode mode, string hostname, int portnumber) { //if already running, deactivate before starting anew if (isActive) Deactivate(); //lock calling thread while initializing initializationLock = Thread.CurrentThread; lock (initializationLock) { apiManager = new GazeApiManager(this); apiManager.Connect(hostname, portnumber); if (apiManager.IsConnected()) { apiManager.RequestTracker(mode, apiVersion); apiManager.RequestAllStates(); //We wait untill above requests have been handled by server or timeout occours bool waitSuccess = Monitor.Wait(initializationLock, TimeSpan.FromSeconds(20)); if (waitSuccess == false) { Debug.WriteLine("Error initializing GazeManager"); return false; } //init heartbeat heartbeatHandler = new Heartbeat(apiManager); heartbeatHandler.Start(); isActive = true; } else Debug.WriteLine("Error initializing GazeManager"); return isActive; } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.Configure <CookiePolicyOptions>( options => { // This lambda determines whether user consent for non-essential cookies is needed for a given request. options.CheckConsentNeeded = context => true; options.MinimumSameSitePolicy = SameSiteMode.None; }); services.AddAuthentication(AzureADDefaults.AuthenticationScheme) .AddAzureAD(options => this.configuration.Bind("AzureAd", options)); services.AddAuthentication(AzureADDefaults.JwtBearerAuthenticationScheme) .AddAzureADBearer(options => this.configuration.Bind("AzureAd", options)); AADAuthHelper.AdminList = this.configuration["ISVPortal:AdminAccounts"].Split(';', StringSplitOptions.RemoveEmptyEntries); AADAuthHelper.AdminTenantId = this.configuration["ISVPortal:AdminTenant"]; services.Configure <JwtBearerOptions>(AzureADDefaults.JwtBearerAuthenticationScheme, options => { // This is a Microsoft identity platform web API. options.Authority += "/v2.0"; // The web API accepts as audiences both the Client ID (options.Audience) and api://{ClientID}. options.TokenValidationParameters.ValidAudiences = new[] { options.Audience, $"api://{options.Audience}", this.configuration["AzureAD:ClientId"], $"api://{this.configuration["AzureAD:ClientId"]}" }; options.ClaimsIssuer = @"https://sts.windows.net/{tenantid}/"; // Instead of using the default validation (validating against a single tenant, // as we do in line-of-business apps), // we inject our own multitenant validation logic (which even accepts both v1 and v2 tokens). options.TokenValidationParameters.IssuerValidator = AadIssuerValidator.GetIssuerValidator(options.Authority).Validate; }); services.Configure <CookieAuthenticationOptions>( AzureADDefaults.CookieScheme, options => options.AccessDeniedPath = "/Subscriptions/NotAuthorized"); services.Configure <OpenIdConnectOptions>( AzureADDefaults.OpenIdScheme, options => { //options.Authority = options.Authority + "/v2.0/"; // Azure AD v2.0 options.TokenValidationParameters.ValidateIssuer = false; // accept several tenants (here simplified) }); services.Configure <DashboardOptions>(this.configuration.GetSection("Dashboard")); services.Configure <AzureOptions>(this.configuration.GetSection("Azure")); services.Configure <ApiBehaviorOptions>(x => { x.InvalidModelStateResponseFactory = context => { var problemDetails = new ErrorModel(context); return(new BadRequestObjectResult(problemDetails) { ContentTypes = { "application/problem+json", "application/problem+xml" } }); }; }); services.AddOptions <SecuredFulfillmentClientConfiguration>().Configure( options => { this.configuration.Bind("FulfillmentClient", options); this.configuration.Bind("SecuredCredentials:Marketplace", options); } ); services.AddHttpClient <IFulfillmentClient, FulfillmentClient>() .SetHandlerLifetime(TimeSpan.FromMinutes(5)) //Set lifetime to five minutes .AddPolicyHandler( (services, request) => HttpPolicyExtensions.HandleTransientHttpError() .OrResult(msg => ExceptionUtils.IsHttpErrorCodeRetryable(msg.StatusCode)) .WaitAndRetryAsync( 3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), onRetry: (result, timeSpan, retryCount, context) => { if (result.Exception != null) { services.GetService <ILogger <IFulfillmentClient> >()? .LogWarning($"An exception occurred on retry {retryCount} at {context.OperationKey} with message {result.Exception.Message}"); } else { services.GetService <ILogger <IFulfillmentClient> >()? .LogError($"An unsuccessful status code {result.Result.StatusCode} was received on retry {retryCount} at {context.OperationKey}"); } } )); // Hack to save the host name and port during the handling the request. Please see the WebhookController and ContosoWebhookHandler implementations services.AddSingleton <ContosoWebhookHandlerOptions>(); services.TryAddScoped <IWebhookProcessor, WebhookProcessor>(); services.TryAddScoped <IFulfillmentManager, FulfillmentManager>(); // Register the provisioning client services.AddOptions <SecuredProvisioningClientConfiguration>().Configure( options => { this.configuration.Bind("ProvisioningClient", options); this.configuration.Bind("SecuredCredentials:ResourceManager", options); } ); //services.TryAddScoped<IProvisioningClient, ProvisioningClient>(); services.AddHttpClient <IProvisioningClient, ProvisioningClient>() .SetHandlerLifetime(TimeSpan.FromMinutes(5)); services.AddHttpClient <ICustomMeteringClient, CustomMeteringClient>(); // Get the connection string from appsettings.json string connectionString = this.configuration.GetValue <string>(this.configuration["SecuredCredentials:Database:ConnectionString"]); // Database context must be registered with the dependency injection (DI) container services.AddDbContext <SqlDbContext>(options => options.UseSqlServer(connectionString)); // Register the db context interface services.TryAddScoped <ISqlDbContext, SqlDbContext>(); services.AddOptions <StorageAccountConfigurationOption>().Configure( options => { this.configuration.Bind("SecuredCredentials:StorageAccount", options); } ); // Register the storage utility interface services.TryAddScoped <IStorageUtility, StorageUtility>(); services.TryAddScoped <IKeyVaultHelper, KeyVaultHelper>(); // Register the provisioning helper services.TryAddScoped <IMarketplaceNotificationHandler, ProvisioningHelper>(); // Register the entity services services.TryAddScoped <IOfferService, OfferService>(); services.TryAddScoped <IArmTemplateService, ArmTemplateService>(); services.TryAddScoped <IPlanService, PlanService>(); services.TryAddScoped <ISubscriptionService, SubscriptionService>(); services.TryAddScoped <IAadSecretTmpService, AadSecretTmpService>(); services.TryAddScoped <IArmTemplateParameterService, ArmTemplateParameterService>(); services.TryAddScoped <ICustomMeterService, CustomMeterService>(); services.TryAddScoped <ICustomMeterDimensionService, CustomMeterDimensionService>(); services.TryAddScoped <IIpConfigService, IpConfigService>(); services.TryAddScoped <IOfferParameterService, OfferParameterService>(); services.TryAddScoped <IRestrictedUserService, RestrictedUserService>(); services.TryAddScoped <IWebhookService, WebhookService>(); services.TryAddScoped <IWebhookParameterService, WebhookParameterService>(); services.TryAddScoped <IProvisioningService, ProvisioningService>(); services.TryAddScoped <IIpAddressService, IpAddressService>(); services.TryAddScoped <ISubscriptionParameterService, SubscriptionParameterService>(); services.TryAddScoped <IWebhookWebhookParameterService, WebhookWebhookParameterService>(); services.TryAddScoped <IArmTemplateArmTemplateParameterService, ArmTemplateArmTemplateParameterService>(); services.TryAddScoped <ITelemetryDataConnectorService, TelemetryDataConnectorService>(); services.TryAddScoped <ISubscriptionCustomMeterUsageService, SubscriptionCustomMeterUsageService>(); services.TryAddScoped <ICustomMeterEventService, CustomMeterEventService>(); // Register luna db client services.AddHttpClient("Luna", x => { x.BaseAddress = new Uri(configuration.GetValue <string>("LunaClient:BaseUri")); }); services.TryAddScoped <LunaClient>(); services.AddCors(); services.AddRazorPages(); services.AddApiVersioning(o => { DateTime groupVersion = DateTime.ParseExact(apiVersion, "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture); ApiVersion latest = new ApiVersion(groupVersion); o.ReportApiVersions = true; o.AssumeDefaultVersionWhenUnspecified = true; o.DefaultApiVersion = latest; o.Conventions.Controller <OfferController>().HasApiVersion(latest); o.Conventions.Controller <ArmTemplateController>().HasApiVersion(latest); o.Conventions.Controller <PlanController>().HasApiVersion(latest); o.Conventions.Controller <SubscriptionController>().HasApiVersion(latest); o.Conventions.Controller <ArmTemplateParameterController>().HasApiVersion(latest); o.Conventions.Controller <CustomMeterController>().HasApiVersion(latest); o.Conventions.Controller <CustomMeterDimensionController>().HasApiVersion(latest); o.Conventions.Controller <IpConfigController>().HasApiVersion(latest); o.Conventions.Controller <OfferParameterController>().HasApiVersion(latest); o.Conventions.Controller <RestrictedUserController>().HasApiVersion(latest); o.Conventions.Controller <WebhookController>().HasApiVersion(latest); o.Conventions.Controller <WebhookParameterController>().HasApiVersion(latest); }); // Register the Swagger generator, defining 1 or more Swagger documents services.AddSwaggerGen(c => { c.SwaggerDoc(apiVersion, new OpenApiInfo { Title = "Luna Dashboard API", Version = apiVersion }); // Set the comments path for the Swagger JSON and UI. var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"; var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile); c.IncludeXmlComments(xmlPath); }); services.AddApplicationInsightsTelemetry(); }
public TwitterApi(string consumerKey, string consumerSecret, ApiVersion apiVersion = ApiVersion.V1) : this(consumerKey, consumerSecret, "", "", TokenType.InvalidToken, apiVersion) { }
internal virtual void OnValidate(ApiVersion version) { }
private TwitterApi(string consumerKey, string consumerSecret, string accessToken, string tokenSecret, TokenType tokenType, ApiVersion apiVersion = ApiVersion.V1) { var consumerCredential = new ConsumerCredential(consumerKey, consumerSecret); consumerCredential.SetToken(accessToken, tokenSecret, tokenType); var serviceProviderDescription = new ServiceProviderDescription( new OAuthEndPoint("https://api.twitter.com/oauth/request_token"), new OAuthEndPoint("https://api.twitter.com/oauth/authorize", HttpMethod.Get), new OAuthEndPoint("https://api.twitter.com/oauth/access_token"), ProtocolVersion.V10A); this._OAuth = new OAuth(consumerCredential, serviceProviderDescription); this._OAuth.Realm = ApiBaseUri; this._OAuth.Proxy = null; this.ApiVersion = apiVersion; this._Configuration = new TwitterConfiguration(); this._Timer = new Timer(_ => { var newConfig = this.RetrieveConfiguration(); if (newConfig != null) Interlocked.Exchange(ref this._Configuration, newConfig); }, null, 1000, 1000 * 3600 * 24); }
/// <summary> /// Populates the API version parameters for the specified API description. /// </summary> /// <param name="apiDescription">The <see cref="ApiDescription">API description</see> to populate parameters for.</param> /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> used to populate parameters with.</param> protected virtual void PopulateApiVersionParameters(ApiDescription apiDescription, ApiVersion apiVersion) { var parameterSource = Options.ApiVersionParameterSource; var context = new ApiVersionParameterDescriptionContext(apiDescription, apiVersion, modelMetadata.Value, Options); parameterSource.AddParameters(context); }
protected void PrepareApiRequest(BaseAPI api, ApiVersion ver) { if (ver == ApiVersion.V2) api.AppKey = "webapp"; else if(ver == ApiVersion.V3) api.AppKey = "webapp_v3"; }
public async Task <IActionResult> CreateTransaction(CreateTransactionDto transactionDto, ApiVersion version) { var result = await _repository.CreateTransactionAsync(transactionDto); return(CreatedAtRoute(new { id = result.Id, version = $"{version}" }, result)); }