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);
}
