public override async Task <GrpcResponse> Login(LoginRequest request, ServerCallContext context)
{
var loginDto = _mapper.Map <UserLoginDto>(request);
var loginResult = await _accountService.LoginAsync(loginDto);
var grpcResponse = new GrpcResponse()
{
IsSuccessStatusCode = loginResult.IsSuccess
};
if (!grpcResponse.IsSuccessStatusCode)
{
grpcResponse.Error = loginResult.ProblemDetails?.Detail;
return(grpcResponse);
}
var validatedInfo = loginResult.Content;
var loginReply = new LoginReply
{
Token = JwtTokenHelper.CreateAccessToken(_jwtOptions.Value, validatedInfo.ValidationVersion, validatedInfo.Account, validatedInfo.Id.ToString(), validatedInfo.Name, validatedInfo.RoleIds).Token,
RefreshToken = JwtTokenHelper.CreateRefreshToken(_jwtOptions.Value, validatedInfo.ValidationVersion, validatedInfo.Id.ToString()).Token
};
grpcResponse.Content = Any.Pack(loginReply);
return(grpcResponse);
}
public void PublishGrpcResponse(GrpcResponse response)
{
foreach (var observer in _grpcObservers)
{
observer.OnNext(response);
}
}
public ValueTask <GrpcResponse> InsertOrReplaceAsync(RowWithTableNameGrpcRequest request)
{
var dbTable = _dbTablesList.TryGetTable(request.TableName);
var result = new GrpcResponse
{
Status = GrpcResultStatus.Ok
};
if (dbTable == null)
{
result.Status = GrpcResultStatus.TableNotFound;
}
else
{
dbTable.LockWithWriteAccess(writeAccess =>
{
var dbPartition = writeAccess.GetOrCreatePartition(request.DbRow.PartitionKey);
dbPartition.InsertOrReplace(request.DbRow);
_syncEventsQueue.EnqueueDbRowChange(dbTable, request.DbRow);
});
}
_syncEventsPusher.PushEventsToReaders();
return(new ValueTask <GrpcResponse>(result));
}
/// <summary>
/// Authenticates the user.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>the grpc response</returns>
private async Task <GrpcResponse> AuthenticateUser(NetworkUser user)
{
var result = new GrpcResponse()
{
Result = ResultCode.Ok
};
try
{
user.AuthenticationToken = await this.handler.Authenticate(user.LoginName, user.PasswordHash);
if (string.IsNullOrEmpty(user.AuthenticationToken))
{
throw new Exception("Invalid user or password");
}
result.Data.Add(Any.Pack(user));
}
catch (Exception ex)
{
result = new GrpcResponse()
{
Result = ResultCode.Error
};
result.Data.Add(Any.Pack(ex.ToProtoException()));
}
return(result);
}
public ValueTask <GrpcResponse> BulkInsertOrReplaceAsync(RowsWithTableNameGrpcRequest dbRows)
{
var result = new GrpcResponse();
var dbTable = _dbTablesList.TryGetTable(dbRows.TableName);
if (dbTable == null)
{
result.Status = GrpcResultStatus.TableNotFound;
return(new ValueTask <GrpcResponse>(result));
}
var groupByPartitionKey = dbRows.DbRows
.GroupBy(itm => itm.PartitionKey)
.ToDictionary(
itm => itm.Key,
itm => itm.ToList());
dbTable.LockWithWriteAccess(writeAccess =>
{
foreach (var(partitionKey, dbRowsByPartition) in groupByPartitionKey)
{
var partition = writeAccess.GetOrCreatePartition(partitionKey);
partition.InsertOrReplace(dbRowsByPartition);
_syncEventsQueue.EnqueueDbRowsChange(dbTable, partitionKey, dbRowsByPartition);
}
});
_syncEventsPusher.PushEventsToReaders();
result.Status = GrpcResultStatus.Ok;
return(new ValueTask <GrpcResponse>(result));
}
/// <summary>
/// Creates a grpc repsonse as an unauthorization result.
/// </summary>
/// <returns>a grpc response</returns>
protected GrpcResponse Unauthorized()
{
GrpcResponse result = new GrpcResponse();
result.Result = ResultCode.Error;
result.Message = "Access denied";
return(result);
}
/// <summary>
/// Creates a grpc repsonse as a bad request result.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>a grpc response</returns>
protected GrpcResponse BadRequest(string message)
{
GrpcResponse result = new GrpcResponse();
result.Result = ResultCode.Error;
result.Message = message;
return(result);
}
/// <summary>
/// Creates a grpc repsonse as an ok result.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>a grpc response</returns>
protected GrpcResponse Ok(string message = null)
{
GrpcResponse result = new GrpcResponse();
result.Result = ResultCode.Ok;
if (!string.IsNullOrEmpty(message))
{
result.Message = message;
}
return(result);
}
public override async Task <GrpcResponse> GetDict(DictRequest request, ServerCallContext context)
{
var grpcResponse = new GrpcResponse();
var dict = await _dictAppService.GetAsync(request.Id);
if (dict is not null)
{
var replyDict = _mapper.Map <DictReply>(dict);
grpcResponse.Content = Any.Pack(replyDict);
}
grpcResponse.IsSuccessStatusCode = true;
return(grpcResponse);
}
/// <summary>
/// Creates a grpc repsonse as an ok result.
/// </summary>
/// <param name="proto">The proto.</param>
/// <param name="message">The message.</param>
/// <returns>a grpc response</returns>
protected GrpcResponse Ok(IMessage proto, string message = null)
{
GrpcResponse result = new GrpcResponse();
result.Result = ResultCode.Ok;
if (!string.IsNullOrEmpty(message))
{
result.Message = message;
}
if (proto != null)
{
result.Data.Add(Any.Pack(proto));
}
return(result);
}
/// <summary>
/// Creates a grpc repsonse as an ok result.
/// </summary>
/// <param name="proto">The proto.</param>
/// <param name="message">The message.</param>
/// <returns>a grpc response</returns>
protected GrpcResponse Ok(List <IMessage> proto, string message = null)
{
GrpcResponse result = new GrpcResponse();
result.Result = ResultCode.Ok;
if (!string.IsNullOrEmpty(message))
{
result.Message = message;
}
if (proto != null)
{
result.Data.AddRange(proto.Select(p => Any.Pack(p)));
}
return(result);
}
/// <summary>
/// Creates a grpc repsonse as a bad request result.
/// </summary>
/// <param name="ex">The ex.</param>
/// <param name="message">The message.</param>
/// <returns>a grpc response</returns>
protected GrpcResponse BadRequest(Exception ex, string message = null)
{
GrpcResponse result = new GrpcResponse();
result.Result = ResultCode.Error;
if (!string.IsNullOrEmpty(message))
{
result.Message = message;
}
else
{
result.Message = ex.Message;
}
result.Data.Add(Any.Pack(ex.ToProtoException()));
return(result);
}
public override async Task <GrpcResponse> GetProducts(ProductSearchRequest request, ServerCallContext context)
{
var grpcResponse = new GrpcResponse();
var searchDto = _mapper.Map <ProductSearchListDto>(request);
var products = await _productAppService.GetListAsync(searchDto);
var replyProducts = products.IsNullOrEmpty()
? new List <ProductReply>()
: _mapper.Map <List <ProductReply> >(products);
var replyList = new ProductListReply();
replyList.List.AddRange(replyProducts);
grpcResponse.Content = Any.Pack(replyList);
grpcResponse.IsSuccessStatusCode = true;
return(grpcResponse);
}
public override async Task <GrpcResponse> GetDepts(Empty request, ServerCallContext context)
{
var grpcResponse = new GrpcResponse()
{
IsSuccessStatusCode = true
};
var depts = await _deptAppService.GetTreeListAsync();
var replyDepts = depts.IsNullOrEmpty()
? new List <DeptReply>()
: _mapper.Map <List <DeptReply> >(depts);
var replyList = new DeptListReply();
replyList.List.AddRange(replyDepts);
grpcResponse.Content = Any.Pack(replyList);
return(grpcResponse);
}
public ValueTask <GrpcResponse> GcTableAsync(GcTableGrpcRequest request)
{
var result = new GrpcResponse();
var table = _dbTablesList.TryGetTable(request.TableName);
if (table == null)
{
result.Status = GrpcResultStatus.TableNotFound;
return(new ValueTask <GrpcResponse>(result));
}
if (!table.WeHavePartitionsToGc(request.MaxPartitionsAmount))
{
return(new ValueTask <GrpcResponse>(result));
}
table.LockWithWriteAccess(writeAccess =>
{
if (writeAccess.PartitionsCount() > request.MaxPartitionsAmount)
{
return;
}
var itemsByLastAccess = writeAccess.GetPartitions().OrderBy(itm => itm.LastAccessTime).ToList();
var i = 0;
while (writeAccess.PartitionsCount() > request.MaxPartitionsAmount)
{
writeAccess.RemovePartition(itemsByLastAccess[i].PartitionKey);
_syncEventsQueue.EnqueueSyncPartition(table, itemsByLastAccess[i]);
i++;
}
});
_syncEventsPusher.PushEventsToReaders();
return(new ValueTask <GrpcResponse>());
}
public ValueTask <GrpcResponse> GcPartitionAsync(GcPartitionGrpcRequest request)
{
var result = new GrpcResponse();
var table = _dbTablesList.TryGetTable(request.TableName);
if (table == null)
{
result.Status = GrpcResultStatus.TableNotFound;
return(new ValueTask <GrpcResponse>(result));
}
result.Status = GrpcResultStatus.Ok;
var rowsAmount = table.GetAmount(request.PartitionKey);
if (rowsAmount <= request.MaxRowsAmount)
{
return(new ValueTask <GrpcResponse>(result));
}
table.LockWithWriteAccess(writeAccess =>
{
var partition = writeAccess.TryGetPartition(request.PartitionKey);
if (partition == null)
{
return;
}
foreach (var dbRow in partition.Gc(request.MaxRowsAmount))
{
_syncEventsQueue.EnqueueDbRowDelete(table, dbRow);
}
});
_syncEventsPusher.PushEventsToReaders();
return(new ValueTask <GrpcResponse>(result));
}
public override async Task <GrpcResponse> GetCurrenUserPermissions(UserPermissionsRequest request, ServerCallContext context)
{
var grpcResponse = new GrpcResponse()
{
IsSuccessStatusCode = true
};
if (request.UserId != _userContext.Id)
{
grpcResponse.IsSuccessStatusCode = false;
grpcResponse.Error = @"request.UserId != _userContext.Id";
return(grpcResponse);
}
var result = await _userService.GetPermissionsAsync(_userContext.Id, request.RequestPermissions, request.UserBelongsRoleIds);
result ??= new List <string>();
var response = new UserPermissionsReply();
response.Permissions.AddRange(result);
grpcResponse.Content = Any.Pack(response);
return(grpcResponse);
}
/// <summary>
/// Converts a response to a exception
/// </summary>
/// <param name="response">The response.</param>
/// <param name="throwException">The throwException<see cref="bool" /></param>
/// <returns>The <see cref="Exception"/></returns>
public static Exception ToException(this GrpcResponse response, bool throwException = false)
{
if (response.Result != ResultCode.Error)
{
return(null);
}
if (response.Data.Count > 0)
{
return(response.Data.FirstOrDefault().ToException(throwException));
}
else
{
Exception exception = new Exception(response.Message);
if (throwException)
{
throw exception;
}
else
{
return(exception);
}
}
}
/// <summary>
/// Handles the authentication command.
/// </summary>
/// <param name="cmd">The command.</param>
/// <returns>a grpc response</returns>
public async Task <GrpcResponse> HandleCmd(Command cmd)
{
GrpcResponse result = null;
if (cmd.Topic == StaticCommandKeys.TokenValidation)
{
try
{
var user = cmd.Data.FirstOrDefault().CastToModel <NetworkUser>();
if (user == null || string.IsNullOrEmpty(user.AuthenticationToken))
{
throw new Exception("Invalid validation data.");
}
if (!this.handler.Authenticate(user.AuthenticationToken))
{
user.AuthenticationToken = "";
}
result = new GrpcResponse()
{
Result = ResultCode.Ok
};
result.Data.Add(Any.Pack(user));
}
catch (Exception ex)
{
// Todo logging
Console.WriteLine(ex);
result = new GrpcResponse()
{
Result = ResultCode.Error
};
result.Data.Add(Any.Pack(ex.ToProtoException()));
}
return(result);
}
else if (cmd.Topic == StaticCommandKeys.UserValidation)
{
try
{
var user = cmd.Data.FirstOrDefault().CastToModel <NetworkUser>();
if (user == null)
{
throw new Exception("Ivalid validation data.");
}
return(await this.AuthenticateUser(user));
}
catch (Exception ex)
{
// Todo logging
Console.WriteLine(ex);
result = new GrpcResponse()
{
Result = ResultCode.Error
};
result.Data.Add(Any.Pack(ex.ToProtoException()));
}
return(result);
}
else if (cmd.Topic == StaticCommandKeys.Connect)
{
try
{
var user = cmd.Data.FirstOrDefault().CastToModel <NetworkUser>();
if (user == null)
{
throw new Exception("Ivalid authentication data.");
}
if (!string.IsNullOrEmpty(user.AuthenticationToken))
{
if (!this.handler.Authenticate(user.AuthenticationToken))
{
throw new Exception("Invalid token");
}
}
else
{
return(await this.AuthenticateUser(user));
}
}
catch (Exception ex)
{
// Todo logging
Console.WriteLine(ex);
result = new GrpcResponse()
{
Result = ResultCode.Error
};
result.Data.Add(Any.Pack(ex.ToProtoException()));
}
return(result);
}
return(new GrpcResponse()
{
Result = ResultCode.Error, Message = "Invalid Topic"
});
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="cmd">The cmd<see cref="Command"/></param>
/// <param name="streamId">The streamId<see cref="string"/></param>
/// <param name="cloudId">The cloud identifier.</param>
/// <returns>a task</returns>
private async Task <GrpcResponse> HandleCommand(NetworkUser user, Command cmd, string streamId, string cloudId)
{
GrpcResponse result = Ok();
switch (cmd.Topic)
{
case StaticCommandKeys.Connect:
user = cmd.Data.FirstOrDefault()?.CastToModel <NetworkUser>();
if (user == null)
{
throw new Exception("Invalid connection data.");
}
return(await this.tokenObserver.Authenticate(user.LoginName, user.PasswordHash));
case StaticCommandKeys.ServiceMetaData:
ServiceMetaData metaData = cmd.Data.FirstOrDefault()?.CastToModel <ServiceMetaData>();
if (metaData == null)
{
throw new Exception("Invalid data for service meta data information.");
}
if (serviceMetaData.ContainsKey(metaData.ServiceAddress))
{
ServiceMetaData s;
while (!serviceMetaData.TryRemove(metaData.ServiceAddress, out s))
{
await Task.Delay(1);
}
}
while (!serviceMetaData.TryAdd(metaData.ServiceAddress, metaData))
{
await Task.Delay(1);
}
Log("Added service metadata for service " + streamId, LogLevel.Debug);
break;
case StaticCommandKeys.Subscribe:
try
{
SubscriptionMessage msg = cmd.Data.FirstOrDefault()?.CastToModel <SubscriptionMessage>();
if (msg == null)
{
throw new Exception("Invalid data for the subscription message.");
}
Log("Client subscribed to Topic: " + msg.Topic, LogLevel.Debug);
CommonSubscriptionHandler.SubscribeToTopic(streamId, msg.Topic.ToString());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
break;
case StaticCommandKeys.Unsubscribe:
try
{
SubscriptionMessage msg = cmd.Data.FirstOrDefault()?.CastToModel <SubscriptionMessage>();
if (msg == null)
{
throw new Exception("Invalid data for the subscription message.");
}
Log("Client unsubscribed from Topic: " + msg.Topic, LogLevel.Debug);
CommonSubscriptionHandler.UnsubscribeFromTopic(streamId, msg.Topic.ToString());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
break;
default:
string topic = cmd.Topic;
if (!string.IsNullOrEmpty(cmd.TargetId))
{
topic = topic + "/" + cmd.TargetId;
}
CommonSubscriptionHandler.ForwardByTopic(cmd, topic);
break;
}
return(result);
}
