public List <Validator> GetValidators()
{
var(auth, tenantId, adminId, adminEmail) = Authorize();
if (!auth)
{
return(new List <Validator>());
}
var list = _validationReader.Get(ValidatorLinkEntity.GeneratePartitionKey(tenantId));
var result = list.Select(v => new Validator(
v.RowKey,
v.ValidatorId,
v.PublicKeyPem,
v.Name,
v.Position,
v.Description,
v.IsAccepted,
v.IsBlocked,
v.DeviceInfo,
v.CreatedAt,
v.CreatedByAdminId,
v.CreatedByAdminEmail))
.ToList();
return(result);
}
public async Task BlockValidatorAsync([FromBody] ValidatorRequest request)
{
var(auth, tenantId, adminId, adminEmail) = Authorize();
if (!auth)
{
return;
}
var entity = _validationReader.Get(ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(request.ApiKeyId));
if (entity == null)
{
_logger.LogInformation("ValidatorLinkEntity not found by API key: {ApiKeyId}", request.ApiKeyId);
HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
entity.IsBlocked = true;
await _validationWriter.InsertOrReplaceAsync(entity);
_logger.LogInformation("Validator Api Key is Blocked. API key: {ApiKeyId}; ValidatorId: {ValidatorId}; TenantId: {TenantId}; Name: {Name}; AdminId: {AdminId}", request.ApiKeyId, entity.ValidatorId, entity.TenantId, entity.Name, adminId);
}
public async Task <CreateInvitation> CreateInvitationAsync([FromBody] CreateInvitationRequest request)
{
var(auth, tenantId, adminId, adminEmail) = Authorize();
if (!auth)
{
return(new CreateInvitation());
}
var invite = ValidatorLinkEntity.Generate(tenantId, Guid.NewGuid().ToString("N"));
invite.InvitationToken = Guid.NewGuid().ToString("N") + Guid.NewGuid().ToString("N") + Guid.NewGuid().ToString("N");
invite.Name = request.Name;
invite.Position = request.Position;
invite.Description = request.Description;
invite.CreatedAt = DateTime.UtcNow;
invite.CreatedByAdminId = adminId;
invite.CreatedByAdminEmail = adminEmail;
await _validationWriter.InsertOrReplaceAsync(invite);
_logger.LogInformation("Invitation Created. TenantId: {TenantId}; AdminId: {AdminId}", tenantId, adminId);
var resp = new CreateInvitation()
{
TenantId = invite.TenantId,
InvitationToken = invite.InvitationToken,
Name = invite.Name,
Position = invite.Position,
Description = invite.Description
};
return(resp);
}
public override async Task <RemoveVaultConnectionResponse> RemoveVaultConnection(RemoveVaultConnectionRequest request, ServerCallContext context)
{
var tenantId = context.GetHttpContext().User.GetClaimOrDefault(Claims.TenantId);
var apiKeyId = context.GetHttpContext().User.GetClaimOrDefault(Claims.ApiKeyId);
if (string.IsNullOrEmpty(apiKeyId))
{
return(new RemoveVaultConnectionResponse()
{
Error = new ValidatorApiError()
{
Code = ValidatorApiError.Types.ErrorCodes.InternalServerError,
Message = "Incorrect Bearer Token. "
}
});
}
var validatorLinkEntity = _validatorLinkReader.Get(
ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(apiKeyId));
if (validatorLinkEntity != null)
{
await _validatorLinkWriter.DeleteAsync(
ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(apiKeyId));
}
return(new RemoveVaultConnectionResponse());
}
public override Task <GetApprovalRequestsResponse> GetApprovalRequests(GetApprovalRequestsRequests request, ServerCallContext context)
{
var validatorId = context.GetHttpContext().User.GetClaimOrDefault(Claims.KeyKeeperId);
var tenantId = context.GetHttpContext().User.GetTenantIdOrDefault();
var apiKeyId = context.GetHttpContext().User.GetClaimOrDefault(Claims.ApiKeyId);
if (string.IsNullOrEmpty(tenantId))
{
return(Task.FromResult(new GetApprovalRequestsResponse
{
Error = new ValidatorApiError
{
Code = ValidatorApiError.Types.ErrorCodes.Unknown,
Message = "Tenant Id required"
}
}));
}
var validatorLinkEntity = _validatorLinkReader.Get(
ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(apiKeyId));
if (validatorLinkEntity == null)
{
return(Task.FromResult(new GetApprovalRequestsResponse
{
Error = new ValidatorApiError
{
Code = ValidatorApiError.Types.ErrorCodes.ExpiredApiKey,
Message = "API key is expired or deleted",
Data = apiKeyId
}
}));
}
var res = new GetApprovalRequestsResponse();
var requests = _approvalRequestReader.Get(ApprovalRequestMyNoSqlEntity.GeneratePartitionKey(validatorId))
.Where(r => r.IsOpen && r.TenantId == tenantId);
//todo: add filter by tenant from API key, need to add tenant into api key
foreach (var entity in requests)
{
var item = new GetApprovalRequestsResponse.Types.ApprovalRequest()
{
TransferSigningRequestId = entity.TransferSigningRequestId,
Status = GetApprovalRequestsResponse.Types.ApprovalRequest.Types.RequestStatus.Open,
TransactionDetailsEncBase64 = entity.MessageEnc,
SecretEncBase64 = entity.SecretEnc,
IvNonce = entity.IvNonce
};
res.Payload.Add(item);
}
_logger.LogInformation("Return {Count} ApprovalRequests to ValidatorId='{ValidatorId}'", res.Payload.Count, validatorId);
return(Task.FromResult(res));
}
public override async Task <ResolveApprovalRequestsResponse> ResolveApprovalRequests(ResolveApprovalRequestsRequest request, ServerCallContext context)
{
var validatorId = context.GetHttpContext().User.GetClaimOrDefault(Claims.KeyKeeperId);
var tenantId = context.GetHttpContext().User.GetTenantIdOrDefault();
var apiKeyId = context.GetHttpContext().User.GetClaimOrDefault(Claims.ApiKeyId);
var validatorLinkEntity = _validatorLinkReader.Get(
ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(apiKeyId));
if (validatorLinkEntity == null)
{
return(new ResolveApprovalRequestsResponse
{
Error = new ValidatorApiError
{
Code = ValidatorApiError.Types.ErrorCodes.ExpiredApiKey,
Message = "API key is expired or deleted",
Data = apiKeyId
}
});
}
Console.WriteLine($"===============================");
Console.WriteLine("Receive ResolveApprovalRequests:");
Console.WriteLine($"{DateTime.UtcNow:s}");
Console.WriteLine($"validatorId: {validatorId}");
Console.WriteLine($"DeviceInfo: {request.DeviceInfo}");
Console.WriteLine($"TransferSigningRequestId: {request.TransferSigningRequestId}");
Console.WriteLine($"Signature: {request.Signature}");
Console.WriteLine($"ResolutionDocumentEncBase64: {request.ResolutionDocumentEncBase64}");
Console.WriteLine($"-------------------------------");
var approvalRequest = _approvalRequestReader.Get(
ApprovalRequestMyNoSqlEntity.GeneratePartitionKey(validatorId),
ApprovalRequestMyNoSqlEntity.GenerateRowKey(request.TransferSigningRequestId));
if (approvalRequest == null || !approvalRequest.IsOpen)
{
_logger.LogInformation("ResolveApprovalRequests skip because active request not found. TransferSigningRequestId={TransferSigningRequestId}; ValidatorId={ValidatorId}", request.TransferSigningRequestId, validatorId);
return(new ResolveApprovalRequestsResponse());
}
approvalRequest.ResolutionDocumentEncBase64 = request.ResolutionDocumentEncBase64;
approvalRequest.ResolutionSignature = request.Signature;
approvalRequest.IsOpen = false;
await _approvalRequestWriter.InsertOrReplaceAsync(approvalRequest);
_logger.LogInformation("ResolveApprovalRequests processed. TransferSigningRequestId={TransferSigningRequestId}; ValidatorId={ValidatorId}", request.TransferSigningRequestId, validatorId);
return(new ResolveApprovalRequestsResponse());
}
public async Task PingValidatorAsync([FromBody] PingValidatorRequest request)
{
var(auth, tenantId, adminId, adminEmail) = Authorize();
if (!auth)
{
return;
}
var entity = _validationReader.Get(ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(request.ApiKeyId));
if (entity == null)
{
_logger.LogInformation("Cannot send ping. ValidatorLinkEntity not found by API key: {ApiKeyId}", request.ApiKeyId);
HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
if (!entity.IsAccepted)
{
_logger.LogInformation("Cannot send ping. ValidatorLinkEntity is not accepted: {ApiKeyId}", request.ApiKeyId);
HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
if (string.IsNullOrEmpty(request.Message))
{
_logger.LogInformation("Cannot send ping. Message cannot be empty: {ApiKeyId}", request.ApiKeyId);
HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
if (Encoding.UTF8.GetBytes(request.Message).Length > 100)
{
_logger.LogInformation("Cannot send ping. Message length in bytes more that 100: {ApiKeyId}; Message: {Message}", request.ApiKeyId, request.Message);
HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
var message = PingMessageMyNoSqlEntity.Generate(entity.ValidatorId, request.Message);
await _pingMessageWriter.InsertOrReplaceAsync(message);
_logger.LogInformation("Ping message are created. API key: {ApiKeyId}; ValidatorId: {ValidatorId}; TenantId: {TenantId}; Name: {Name}; AdminId: {AdminId}", request.ApiKeyId, entity.ValidatorId, entity.TenantId, entity.Name, adminId);
}
public override async Task <RefreshPushNotificationFCMTokenResponse> RefreshPushNotificationFCMToken(RefreshPushNotificationFCMTokenRequest request, ServerCallContext context)
{
var tenantId = context.GetHttpContext().User.GetClaimOrDefault(Claims.TenantId);
var apiKeyId = context.GetHttpContext().User.GetClaimOrDefault(Claims.ApiKeyId);
if (string.IsNullOrEmpty(apiKeyId))
{
return(new RefreshPushNotificationFCMTokenResponse()
{
Error = new ValidatorApiError()
{
Code = ValidatorApiError.Types.ErrorCodes.InternalServerError,
Message = "Incorrect Bearer Token. "
}
});
}
var validatorLinkEntity = _validatorLinkReader.Get(
ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(apiKeyId));
if (validatorLinkEntity != null)
{
validatorLinkEntity.PushNotificationFcmToken = request.PushNotificationFCMToken;
await _validatorLinkWriter.InsertOrReplaceAsync(validatorLinkEntity);
_logger.LogInformation("Refresh PushNotificationFcmToken. ValidatorId='{ValidatorId}'; PushNotificationFcmToken='{PushNotificationFcmToken}'", validatorLinkEntity.ValidatorId, request.PushNotificationFCMToken);
}
else
{
return(new RefreshPushNotificationFCMTokenResponse
{
Error = new ValidatorApiError
{
Code = ValidatorApiError.Types.ErrorCodes.ExpiredApiKey,
Message = "API key is expired or deleted",
Data = apiKeyId
}
});
}
return(new RefreshPushNotificationFCMTokenResponse());
}
public async Task RemoveValidatorApiKeyAsync([FromBody] ValidatorRequest request)
{
var(auth, tenantId, adminId, adminEmail) = Authorize();
if (!auth)
{
return;
}
var entity = _validationReader.Get(ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(request.ApiKeyId));
if (entity == null)
{
return;
}
await _validationWriter.DeleteAsync(entity.PartitionKey, entity.RowKey);
_logger.LogInformation("Removed validator Api Key: {ApiKeyId}; AdminId: {AdminId}; Name: {Name}; Device: {Device}; TenantId: {TenantId}", request.ApiKeyId, adminId, entity.Name, entity.DeviceInfo, tenantId);
}
