private async Task <Authorization> AddAuthorization(Organization organization) { var resourceTask = new PermissionResource(PermissionResource.TypeEnum.Tasks, null, null, organization.Id); var resourceBucket = new PermissionResource(PermissionResource.TypeEnum.Buckets, (await Client.GetBucketsApi().FindBucketByNameAsync("my-bucket")).Id, null, organization.Id); var resourceOrg = new PermissionResource(PermissionResource.TypeEnum.Orgs); var resourceUser = new PermissionResource(PermissionResource.TypeEnum.Users); var resourceAuthorization = new PermissionResource(PermissionResource.TypeEnum.Authorizations); var authorization = await Client.GetAuthorizationsApi() .CreateAuthorizationAsync(organization, new List <Permission> { new Permission(Permission.ActionEnum.Read, resourceTask), new Permission(Permission.ActionEnum.Write, resourceTask), new Permission(Permission.ActionEnum.Read, resourceOrg), new Permission(Permission.ActionEnum.Write, resourceOrg), new Permission(Permission.ActionEnum.Write, resourceUser), new Permission(Permission.ActionEnum.Write, resourceAuthorization), new Permission(Permission.ActionEnum.Read, resourceBucket), new Permission(Permission.ActionEnum.Write, resourceBucket) }); return(authorization); }
/// <inheritdoc /> /// <summary> /// Create a new permission <b>Permissions Needed:</b> PERMISSIONS_ADMIN /// </summary> /// <param name="permissionResource">The permission resource object</param> public void CreatePermission(PermissionResource permissionResource) { mWebCallEvent.WebPath = "/auth/permissions"; if (!string.IsNullOrEmpty(mWebCallEvent.WebPath)) { mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json"); } mWebCallEvent.HeaderParams.Clear(); mWebCallEvent.QueryParams.Clear(); mWebCallEvent.AuthSettings.Clear(); mWebCallEvent.PostBody = null; mWebCallEvent.PostBody = KnetikClient.Serialize(permissionResource); // http body (model) parameter // authentication settings mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant"); // authentication settings mWebCallEvent.AuthSettings.Add("oauth2_password_grant"); // make the HTTP request mCreatePermissionStartTime = DateTime.Now; mWebCallEvent.Context = mCreatePermissionResponseContext; mWebCallEvent.RequestType = KnetikRequestType.POST; KnetikLogger.LogRequest(mCreatePermissionStartTime, "CreatePermission", "Sending server request..."); KnetikGlobalEventSystem.Publish(mWebCallEvent); }
public new async Task SetUp() { _organization = await FindMyOrg(); var retention = new BucketRetentionRules(BucketRetentionRules.TypeEnum.Expire, 3600); _bucket = await Client.GetBucketsApi() .CreateBucketAsync(GenerateName("h2o"), retention, _organization); // // Add Permissions to read and write to the Bucket // var resource = new PermissionResource(PermissionResource.TypeEnum.Buckets, _bucket.Id, null, _organization.Id); var readBucket = new Permission(Permission.ActionEnum.Read, resource); var writeBucket = new Permission(Permission.ActionEnum.Write, resource); var loggedUser = await Client.GetUsersApi().MeAsync(); Assert.IsNotNull(loggedUser); var authorization = await Client.GetAuthorizationsApi() .CreateAuthorizationAsync(await FindMyOrg(), new List <Permission> { readBucket, writeBucket }); _token = authorization.Token; Client.Dispose(); var options = new InfluxDBClientOptions.Builder().Url(InfluxDbUrl).AuthenticateToken(_token.ToCharArray()) .Org(_organization.Id).Bucket(_bucket.Id).Build(); Client = InfluxDBClientFactory.Create(options); }
private string GenerateWriteToken(InfluxDBClient createBucketClient, Bucket bucket) { var resource = new PermissionResource { Id = bucket.Id, OrgID = _connectionInfo.OrganizationId, Type = PermissionResource.TypeEnum.Buckets }; var write = new Permission(Permission.ActionEnum.Write, resource); var authorizationRequest = new AuthorizationPostRequest(_connectionInfo.OrganizationId, permissions: new List <Permission> { write }, description: $"{nameof(Permission.ActionEnum.Write)} Token for Bucket '{bucket.Name}' (Serilog)"); string token; try { var authorizationCreated = createBucketClient.GetAuthorizationsApi() .CreateAuthorizationAsync(authorizationRequest) .GetAwaiter().GetResult(); token = authorizationCreated?.Token; } catch (HttpException ex) { SelfLog.WriteLine($"Error while trying to get {_connectionInfo.BucketName} (Org: {_connectionInfo.OrganizationId}), Message : {ex.Message}. Check if Token has enough access to read (if only write to bucket then set to False parameter {_connectionInfo.CreateBucketIfNotExists}) or set AllAccessToken or is active token"); throw new InfluxDbClientCreateBucketException($"Cannot create token for bucket {_connectionInfo.BucketName} with write permissions. Check if Token has enough access or set AllAccessToken or is active", ex); } SelfLog.WriteLine($"Token generated successfully for bucket {bucket.Name}, using it for write operations"); return(token); }
private async Task <Authorization> CreateAuthorizationToken(InfluxDBClient influxDBClient, Bucket bucket) { var resource = new PermissionResource { Id = bucket.Id, OrgID = bucket.OrgID, Type = PermissionResource.TypeEnum.Buckets }; var read = new Permission(Permission.ActionEnum.Read, resource); var write = new Permission(Permission.ActionEnum.Write, resource); var authorizations = await influxDBClient.GetAuthorizationsApi().FindAuthorizationsAsync(); var authorization = authorizations.FirstOrDefault(a => a.OrgID == bucket.OrgID && a.User == _options.User); if (authorization == null) { authorization = await influxDBClient.GetAuthorizationsApi() .CreateAuthorizationAsync(new Authorization( bucket.OrgID, new List <Permission> { read, write } )); } return(authorization); }
public void AddPermissionResource(PermissionResource resource, string defaultRole) { var dict = resource.ToDictionary(); dict.Add("DefaultRole", defaultRole); DataService.Execute("AddPermissionResource", dict); }
private List <Permission> NewPermissions() { var resource = new PermissionResource { Type = PermissionResource.TypeEnum.Users, OrgID = _organization.Id }; var permission = new Permission(Permission.ActionEnum.Read, resource); var permissions = new List <Permission> { permission }; return(permissions); }
private void OnUpdatePermissionResponse(KnetikRestResponse response) { if (!string.IsNullOrEmpty(response.Error)) { throw new KnetikException("Error calling UpdatePermission: " + response.Error); } UpdatePermissionData = (PermissionResource)KnetikClient.Deserialize(response.Content, typeof(PermissionResource), response.Headers); KnetikLogger.LogResponse(mUpdatePermissionStartTime, "UpdatePermission", string.Format("Response received successfully:\n{0}", UpdatePermissionData)); if (UpdatePermissionComplete != null) { UpdatePermissionComplete(response.ResponseCode, UpdatePermissionData); } }
public ActionResult ResourceEdit(string id) { PermissionResource model; if (!string.IsNullOrEmpty(id)) { var permissions = this.PermissionServer.GetPermissionResources(); model = permissions.SingleOrDefault(x => x.PermissionNo == id); if (model == null) { return(this.Content("权限资源不存在")); } } else { model = new PermissionResource { PermissionNo = id, Enabled = true }; } return(this.View(model)); }
/// <inheritdoc /> /// <summary> /// Update a permission <b>Permissions Needed:</b> PERMISSIONS_ADMIN /// </summary> /// <param name="permission">The permission value</param> /// <param name="permissionResource">The permission resource object</param> public void UpdatePermission(string permission, PermissionResource permissionResource) { // verify the required parameter 'permission' is set if (permission == null) { throw new KnetikException(400, "Missing required parameter 'permission' when calling UpdatePermission"); } mWebCallEvent.WebPath = "/auth/permissions/{permission}"; if (!string.IsNullOrEmpty(mWebCallEvent.WebPath)) { mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json"); } mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "permission" + "}", KnetikClient.ParameterToString(permission)); mWebCallEvent.HeaderParams.Clear(); mWebCallEvent.QueryParams.Clear(); mWebCallEvent.AuthSettings.Clear(); mWebCallEvent.PostBody = null; mWebCallEvent.PostBody = KnetikClient.Serialize(permissionResource); // http body (model) parameter // authentication settings mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant"); // authentication settings mWebCallEvent.AuthSettings.Add("oauth2_password_grant"); // make the HTTP request mUpdatePermissionStartTime = DateTime.Now; mWebCallEvent.Context = mUpdatePermissionResponseContext; mWebCallEvent.RequestType = KnetikRequestType.PUT; KnetikLogger.LogRequest(mUpdatePermissionStartTime, "UpdatePermission", "Sending server request..."); KnetikGlobalEventSystem.Publish(mWebCallEvent); }
public static async Task Example(InfluxDBClient influxDB) { var organizationClient = influxDB.GetOrganizationsApi(); var medicalGMBH = await organizationClient .CreateOrganization("Medical Corp " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture)); // // Create New Bucket with retention 1h // var temperatureBucket = await influxDB.GetBucketsApi().CreateBucket("temperature-sensors", medicalGMBH.Id); // // Add Permissions to read and write to the Bucket // var resource = new PermissionResource { Type = PermissionResource.TypeEnum.Buckets, OrgID = medicalGMBH.Id, Id = temperatureBucket.Id }; var readBucket = new Permission { Resource = resource, Action = Permission.ActionEnum.Read }; var writeBucket = new Permission { Resource = resource, Action = Permission.ActionEnum.Write }; var authorization = await influxDB.GetAuthorizationsApi() .CreateAuthorization(medicalGMBH, new List <Permission> { readBucket, writeBucket }); Console.WriteLine($"The token to write to temperature-sensors bucket is: {authorization.Token}"); influxDB.Dispose(); // // Create new client with specified authorization token // influxDB = InfluxDBClientFactory.Create("http://localhost:9999", authorization.Token.ToCharArray()); var writeOptions = WriteOptions .CreateNew() .BatchSize(5000) .FlushInterval(1000) .JitterInterval(1000) .RetryInterval(5000) .Build(); // // Write data // using (var writeClient = influxDB.GetWriteApi(writeOptions)) { // // Write by POCO // var temperature = new Temperature { Location = "south", Value = 62D, Time = DateTime.UtcNow }; writeClient.WriteMeasurement("temperature-sensors", medicalGMBH.Id, WritePrecision.Ns, temperature); // // Write by Point // var point = Point.Measurement("temperature") .Tag("location", "west") .Field("value", 55D) .Timestamp(DateTime.UtcNow.AddSeconds(-10), WritePrecision.Ns); writeClient.WritePoint("temperature-sensors", medicalGMBH.Id, point); // // Write by LineProtocol // var record = "temperature,location=north value=60.0"; writeClient.WriteRecord("temperature-sensors", medicalGMBH.Id, WritePrecision.Ns, record); writeClient.Flush(); Thread.Sleep(2000); } // // Read data // var fluxTables = await influxDB.GetQueryApi().Query("from(bucket:\"temperature-sensors\") |> range(start: 0)", medicalGMBH.Id); fluxTables.ForEach(fluxTable => { var fluxRecords = fluxTable.Records; fluxRecords.ForEach(fluxRecord => { Console.WriteLine($"{fluxRecord.GetTime()}: {fluxRecord.GetValue()}"); }); }); influxDB.Dispose(); }
/// <summary> /// Update a permission <b>Permissions Needed:</b> PERMISSIONS_ADMIN /// </summary> /// <exception cref="com.knetikcloud.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="permission">The permission value</param> /// <param name="permissionResource">The permission resource object (optional)</param> /// <returns>ApiResponse of PermissionResource</returns> public ApiResponse <PermissionResource> UpdatePermissionWithHttpInfo(string permission, PermissionResource permissionResource = null) { // verify the required parameter 'permission' is set if (permission == null) { throw new ApiException(400, "Missing required parameter 'permission' when calling Auth_PermissionsApi->UpdatePermission"); } var localVarPath = "/auth/permissions/{permission}"; var localVarPathParams = new Dictionary <String, String>(); var localVarQueryParams = new List <KeyValuePair <String, String> >(); var localVarHeaderParams = new Dictionary <String, String>(Configuration.DefaultHeader); var localVarFormParams = new Dictionary <String, String>(); var localVarFileParams = new Dictionary <String, FileParameter>(); Object localVarPostBody = null; // to determine the Content-Type header String[] localVarHttpContentTypes = new String[] { "application/json" }; String localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes); // to determine the Accept header String[] localVarHttpHeaderAccepts = new String[] { "application/json" }; String localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts); if (localVarHttpHeaderAccept != null) { localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept); } if (permission != null) { localVarPathParams.Add("permission", Configuration.ApiClient.ParameterToString(permission)); // path parameter } if (permissionResource != null && permissionResource.GetType() != typeof(byte[])) { localVarPostBody = Configuration.ApiClient.Serialize(permissionResource); // http body (model) parameter } else { localVarPostBody = permissionResource; // byte array } // authentication (oauth2_client_credentials_grant) required // oauth required if (!String.IsNullOrEmpty(Configuration.AccessToken)) { localVarHeaderParams["Authorization"] = "Bearer " + Configuration.AccessToken; } // authentication (oauth2_password_grant) required // oauth required if (!String.IsNullOrEmpty(Configuration.AccessToken)) { localVarHeaderParams["Authorization"] = "Bearer " + Configuration.AccessToken; } // make the HTTP request IRestResponse localVarResponse = (IRestResponse)Configuration.ApiClient.CallApi(localVarPath, Method.PUT, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams, localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int)localVarResponse.StatusCode; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("UpdatePermission", localVarResponse); if (exception != null) { throw exception; } } return(new ApiResponse <PermissionResource>(localVarStatusCode, localVarResponse.Headers.ToDictionary(x => x.Name, x => x.Value.ToString()), (PermissionResource)Configuration.ApiClient.Deserialize(localVarResponse, typeof(PermissionResource)))); }
/// <summary> /// Update a permission <b>Permissions Needed:</b> PERMISSIONS_ADMIN /// </summary> /// <exception cref="com.knetikcloud.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="permission">The permission value</param> /// <param name="permissionResource">The permission resource object (optional)</param> /// <returns>PermissionResource</returns> public PermissionResource UpdatePermission(string permission, PermissionResource permissionResource = null) { ApiResponse <PermissionResource> localVarResponse = UpdatePermissionWithHttpInfo(permission, permissionResource); return(localVarResponse.Data); }
/// <summary> /// Create a new permission <b>Permissions Needed:</b> PERMISSIONS_ADMIN /// </summary> /// <exception cref="com.knetikcloud.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="permissionResource">The permission resource object (optional)</param> /// <returns>PermissionResource</returns> public PermissionResource CreatePermission(PermissionResource permissionResource = null) { ApiResponse <PermissionResource> localVarResponse = CreatePermissionWithHttpInfo(permissionResource); return(localVarResponse.Data); }
public ActionResult ResourceEdit(string id, PermissionResource resource) { this.ViewBag.Result = string.IsNullOrEmpty(id) ? this.PermissionServer.AddPermissionResource(resource) : this.PermissionServer.UpdatePermissionResource(resource); return(this.ResourceEdit(id)); }
public void UpdatePermissionResource(PermissionResource resource) { DataService.Execute("UpdatePermissionResource", resource); }