public override async Task <SendStoryResponse> SendStory(SendStoryCommand request, ServerCallContext context)
{
var command = new SendStory(default, Guid.Parse(request.UserId), request.Title,
public override Task <SimpleResponse> DoSimple(SimpleRequest request, ServerCallContext context)
=> Task.FromResult(new SimpleResponse {
Name = request.Name
});
public override async Task <AddAlphaResponse> AddAlpha(AddAlphaRequest request, ServerCallContext context)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
logger.LogInformation(request.ToString());
var response = new AddAlphaResponse
{
Id = request.Id
};
await Task.Delay(100);
logger.LogInformation(response.ToString());
return(response);
}
public virtual global::System.Threading.Tasks.Task <global::Device.Empty> latest_gas_usage(global::Device.GasUsage request, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task get_temperature(global::Device.Device request, IServerStreamWriter <global::Device.Temperature> responseStream, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
public override async Task StartJobObserver(StringValue request, IServerStreamWriter <Job> responseStream, ServerCallContext context)
{
var cancellationToken = new CancellationTokenSource();
_jobService.AddJobObserver(request.Value, responseStream);
Task t = Task.Run(() =>
{
do
{
Task.Delay(1000).Wait();
} while (!cancellationToken.IsCancellationRequested && !context.CancellationToken.IsCancellationRequested);
});
await t;
}
public override Task <CreateClientResponse> CreateClient(CreateClientRequest request, ServerCallContext context)
{
bool success = RequestsDispatcher.CreateClientProcess(GetClientArguments(request));
if (!success)
{
throw new RpcException(new Status(StatusCode.Internal, "Couldn't create client process."));
}
return(Task.FromResult(new CreateClientResponse()));
}
public override async Task <UpdateProfessorResponse> UpdateProfessorById(UpdateProfessorRequest request, ServerCallContext context)
{
_logger.Log(LogLevel.Debug, "Request Received for CollegeGrpcService::UpdateProfessorById");
var updatedProfessor = new UpdateProfessorResponse
{
Message = "success"
};
var professor = new Professor
{
ProfessorId = Guid.Parse(request.ProfessorId),
Name = request.Name,
Teaches = request.Teaches,
Salary = Convert.ToDecimal(request.Salary),
IsPhd = request.IsPhd
};
professor = await _professorsBll.UpdateProfessor(professor);
updatedProfessor.Professor = GetProfessorObject(professor);
_logger.Log(LogLevel.Debug, "Returning the results from CollegeGrpcService::UpdateProfessorById");
return(updatedProfessor);
}
public override async Task <AwsIamAuthReply> AwsIamAuth(AwsIamAuthRequest request,
ServerCallContext context)
{
if (_config.AwsIamMapping == null)
{
throw new Exception("missing AWS IAM configuration -- AWS IAM mapping is unsupported");
}
var nowUtc = DateTime.UtcNow;
var amzDateMin = nowUtc.AddMinutes(-5);
var amzDateMax = nowUtc.AddMinutes(5);
var amzDate = DateTime.ParseExact(request.StsAmzIso8601Date,
AwsIamConstants.ISO8601DateTimeFormat, null).ToUniversalTime();
if (amzDate < amzDateMin || amzDate > amzDateMax)
{
throw new Exception("AMZ Date outside of valid range");
}
using var httpBody = new StringContent(
AwsIamConstants.AwsIamRequestContent,
AwsIamConstants.AwsIamRequestContentEncoding,
AwsIamConstants.AwsIamRequestContentMediaType);
using var httpRequ = new HttpRequestMessage(
AwsIamConstants.AwsIamRequestHttpMethod,
AwsIamConstants.AwsIamRequestEndpoint)
{
Content = httpBody,
};
foreach (var h in request.StsAdditionalHeaders)
{
httpRequ.Headers.Add(h.Key, h.Value.Values);
}
if (!httpRequ.Headers.TryAddWithoutValidation("Authorization", request.StsAuthorization))
{
throw new Exception("could not add AWSv4 Authorization header");
}
using var http = new HttpClient();
using var httpResp = await http.SendAsync(httpRequ);
httpResp.EnsureSuccessStatusCode();
using var httpRespStream = await httpResp.Content.ReadAsStreamAsync();
var httpRespResult = AwsStsGetCallerIdentityResponse.ParseXml(httpRespStream);
var identityArn = httpRespResult?.GetCallerIdentityResult?.Arn;
if (string.IsNullOrEmpty(identityArn))
{
throw new Exception("could not authenticate or resolve IAM Identity ARN");
}
var userMap = _config.AwsIamMapping.Users.FirstOrDefault(u => u.Arn == identityArn ||
(u.Arn.EndsWith("*") &&
identityArn.StartsWith(u.Arn.Substring(0, u.Arn.Length - 1))));
if (userMap == null)
{
throw new Exception("user has no mapping");
}
ByteString sig = ByteString.Empty;
if (!(request.Nonce?.IsEmpty ?? true))
{
var nonce = request.Nonce.ToByteArray();
var nkeys = Nkeys.FromSeed(userMap.NKey);
sig = ByteString.CopyFrom(nkeys.Sign(nonce));
}
return(new AwsIamAuthReply
{
Jwt = userMap.JWT,
NonceSigned = sig,
IdentityArn = httpRespResult.GetCallerIdentityResult?.Arn,
});
}
public override async Task <AllProfessorsResonse> GetAllProfessors(Empty request, ServerCallContext context)
{
AllProfessorsResonse allProfessorsResonse = new AllProfessorsResonse();
_logger.Log(LogLevel.Debug, "Request Received for CollegeGrpcService::GetAllProfessors");
var allProfessors = await _professorsBll.GetAllProfessors();
allProfessorsResonse.Count = allProfessors.Count();
foreach (var professor in allProfessors)
{
// TODO: Remove Technical Debt
allProfessorsResonse.Professors.Add(GetProfessorObject(professor));
}
_logger.Log(LogLevel.Debug, "Returning the results from CollegeGrpcService::GetAllProfessors");
return(allProfessorsResonse);
}
public override async Task <GetProfessorResponse> GetProfessorById(GetProfessorRequest request, ServerCallContext context)
{
_logger.Log(LogLevel.Debug, "Request Received for CollegeGrpcService::GetProfessorById");
Professor professor = await _professorsBll.GetProfessorById(Guid.Parse(request.ProfessorId));
GetProfessorResponse getProfessorResponse = GetProfessorObject(professor);
_logger.Log(LogLevel.Debug, "Returning the results from CollegeGrpcService::GetProfessorById");
return(getProfessorResponse);
}
public override async Task <NewProfessorResponse> AddProfessor(NewProfessorRequest request, ServerCallContext context)
{
_logger.Log(LogLevel.Debug, "Request Received for CollegeGrpcService::AddProfessor");
var newProfessor = new NewProfessorResponse
{
Message = "success"
};
var professor = new Professor
{
Name = request.Name,
Doj = request.Doj.ToDateTime(),
Teaches = request.Teaches,
Salary = Convert.ToDecimal(request.Salary),
IsPhd = request.IsPhd
};
var results = await _professorsBll.AddProfessor(professor);
newProfessor.ProfessorId = results.ProfessorId.ToString();
_logger.Log(LogLevel.Debug, "Returning the results from CollegeGrpcService::AddProfessor");
return(newProfessor);
}
public override async Task <DeleteProfessorResponse> DeleteProfessorById(DeleteProfessorRequest request, ServerCallContext context)
{
_logger.Log(LogLevel.Debug, "Request Received for CollegeGrpcService::DeleteProfessorById");
var professorDeleted = new DeleteProfessorResponse
{
ProfessorId = request.ProfessorId.ToString(),
Message = "Professor Deleted"
};
professorDeleted.Success = await _professorsBll.DeleteProfessorById(Guid.Parse(request.ProfessorId));
_logger.Log(LogLevel.Debug, "Returning the results from CollegeGrpcService::DeleteProfessorById");
return(professorDeleted);
}
public override Task <CustomerDataModel> GetCustomerInfo(CustomerFindModel request, ServerCallContext context)
{
var model = new CustomerDataModel();
if (request.UserId == 1)
{
model.FirstName = "Ivan";
model.LastName = "Zhang";
}
else if (request.UserId == 2)
{
model.FirstName = "Eva";
model.LastName = "Zhang";
}
else if (request.UserId == 3)
{
model.FirstName = "Guopin";
model.LastName = "Zhao";
}
else
{
model.FirstName = "Yina";
model.LastName = "Zhang";
}
return(Task.FromResult(model));
}
public override async Task <StringValue> LoginAsStreamer(StringValue request, ServerCallContext context)
{
var userKey = new StringValue {
Value = await _loginService.LoginAsStreamerAsync(request.Value)
};
return(userKey);
}
public virtual global::System.Threading.Tasks.Task <global::HOLMS.Types.Operations.RPC.ContinuousRoomClaimsSvcSearchResponse> SearchContinuousClaims(global::HOLMS.Types.Operations.RPC.RoomClaimsSvcSearchRequest request, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
public override async Task StreamerHoldingLine(StringValue request, IServerStreamWriter <Empty> responseStream, ServerCallContext context)
{
var userkey = request.Value;
try
{
do
{
await Task.Delay(5000);
await responseStream.WriteAsync(new Empty());
} while (!context.CancellationToken.IsCancellationRequested);
}
catch (InvalidOperationException) // Streamer disconnects -> writing failure
{
_loginService.StreamerDisconnected(userkey);
}
}
public virtual global::System.Threading.Tasks.Task <global::HOLMS.Types.Operations.RPC.RoomClaimsSvcGetClaimableByReservationResponse> GetClaimableByReservation(global::HOLMS.Types.Operations.RPC.RoomClaimsSvcGetClaimableByReservationRequest request, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
public override async Task Subscribe(IAsyncStreamReader <SubscribeRequest> requestStream, IServerStreamWriter <SampleEventArgsMessage> responseStream, ServerCallContext context)
{
var requesterHeader = context.RequestHeaders.FirstOrDefault(x => x.Key == Constants.Requester.ToLower()); // Must be lower case. Ugh!
var peer = context.Peer;
var requester = requesterHeader == null ? $"Anonymous@{peer}" : $"{requesterHeader.Value}@{peer}";
while (await requestStream.MoveNext())
{
var request = requestStream.Current;
var key = new SampleEventKey(request.AccountName, requester);
if (request.StartStop)
{
var writer = new AccountSampleEventWriter(key, responseStream, _logControl, RemoveWriter);
_eventWriters.TryAdd(key, writer);
OnAccountNameAdded(request.AccountName);
_logControl.LogMessage($"Added subscription to SampleEvents for {AccountNameAdded}");
}
else
{
RemoveWriter(key);
return;
}
}
}
public virtual global::System.Threading.Tasks.Task <global::HOLMS.Types.Operations.RPC.GetAllRoomsWithClaimsResponse> GetAllRoomsWithClaims(global::HOLMS.Types.Operations.RPC.GetAllRoomsWithClaimsRequest request, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
/// <summary>
/// Run image detection and annotation for a batch of images.
/// </summary>
public virtual global::System.Threading.Tasks.Task <global::Google.Cloud.Vision.V1.BatchAnnotateImagesResponse> BatchAnnotateImages(global::Google.Cloud.Vision.V1.BatchAnnotateImagesRequest request, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
public override Task <SecurityLoginPayload> ReadSecurityLogin(IdRequest14 request, ServerCallContext context)
{
var poco = _logic.Get(Guid.Parse(request.Id));
return(new Task <SecurityLoginPayload>(() => new SecurityLoginPayload()
{
Id = poco.Id.ToString(),
Login = poco.Login,
AgreementAccepted = poco.AgreementAccepted is null ?
null :
Timestamp.FromDateTime((DateTime)poco.AgreementAccepted),
Created = Timestamp.FromDateTime(poco.Created),
EmailAddress = poco.EmailAddress,
FullName = poco.FullName,
ForceChangePassword = poco.ForceChangePassword,
IsInactive = poco.IsInactive,
IsLocked = poco.IsLocked,
Password = poco.Password,
PasswordUpdate = poco.PasswordUpdate is null ?
null :
Timestamp.FromDateTime((DateTime)poco.PasswordUpdate),
PhoneNumber = poco.PhoneNumber,
PrefferredLanguage = poco.PrefferredLanguage
}));;
public virtual global::System.Threading.Tasks.Task <global::Device.Empty> set_temperature(global::Device.Temperature request, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
/// <inheritdoc />
public override async Task <HandshakeResponse> Handshake(HandshakeRequest request, ServerCallContext context)
{
try
{
if (!_requestConverter.TryConvert(request, out var parsedRequest, out var failure))
{
Log.RequestParsingFailed(_logger, failure.Reason);
return(FailedResponse(failure));
}
Log.HeadInitiatedHandshake(
_logger,
parsedRequest.Attempt,
parsedRequest.HeadVersion,
parsedRequest.SDK,
parsedRequest.SDKVersion,
parsedRequest.ContractsVersion);
switch (_contractsCompatibility.CheckCompatibility(_runtimeContractsVersion, parsedRequest.ContractsVersion))
{
case ContractsCompatibility.ClientTooOld:
Log.ClientContractsVersionTooOld(_logger, parsedRequest.ContractsVersion, _runtimeContractsVersion);
return(FailedResponse(new SDKMustBeUpdated(_runtimeContractsVersion)));
case ContractsCompatibility.RuntimeTooOld:
Log.RuntimeContractsVersionTooOld(_logger, parsedRequest.ContractsVersion, _runtimeContractsVersion);
return(FailedResponse(new RuntimeMustBeUpdated(parsedRequest.ContractsVersion)));
}
var platformEnvironment = await _platformEnvironment.Resolve().ConfigureAwait(false);
Log.SuccessfulHandshake(
_logger,
parsedRequest.HeadVersion,
parsedRequest.SDK,
parsedRequest.SDKVersion,
platformEnvironment.MicroserviceId,
platformEnvironment.Environment,
parsedRequest.Attempt,
parsedRequest.TimeSpent);
var otlpConfig = _openTelemetryConfig.Value;
var response = new HandshakeResponse
{
RuntimeVersion = _runtimeVersion.ToProtobuf(),
ContractsVersion = _runtimeContractsVersion.ToProtobuf(),
CustomerId = platformEnvironment.CustomerId.ToProtobuf(),
CustomerName = platformEnvironment.CustomerName.Value,
ApplicationId = platformEnvironment.ApplicationId.ToProtobuf(),
ApplicationName = platformEnvironment.ApplicationName.Value,
MicroserviceId = platformEnvironment.MicroserviceId.ToProtobuf(),
MicroserviceName = platformEnvironment.MicroserviceName.Value,
EnvironmentName = platformEnvironment.Environment.Value,
};
if (otlpConfig.Tracing && !string.IsNullOrEmpty(otlpConfig.Endpoint))
{
response.OtlpEndpoint = otlpConfig.Endpoint;
}
return(response);
}
catch (Exception ex)
{
Log.ErrorWhilePerformingHandshake(_logger, ex);
return(FailedResponse(new Failure {
Id = FailureId.Other.ToProtobuf(), Reason = ex.Message
}));
}
}
public override async Task AddNewSensor(IAsyncStreamReader <SensorAddRequest> requestStream,
IServerStreamWriter <SensorResponse> responseStream, ServerCallContext context)
{
while (await requestStream.MoveNext())
{
var newSensor = requestStream.Current.Sensor;
lock (this)
{
Sensores.sensores.Add(newSensor);
}
await responseStream.WriteAsync(new SensorResponse()
{
Sensor = newSensor
});
}
foreach (var sensor in Sensores.sensores)
{
Console.WriteLine(sensor);
}
}
public override Task CreateNewJob(AuthJobRequest request, IServerStreamWriter <JobAnswer> responseStream, ServerCallContext context)
{
_jobService.NewJobRequest(request);
return(Task.CompletedTask);
}
public override async Task <ReturnValidateDiscountCode> ValidateDiscountCode(ValidateDiscountCodeWithCartRequest request, ServerCallContext context)
{
var returnValidateDiscountCode = new ReturnValidateDiscountCode()
{
Status = GrpcStatus.Success
};
var validateDiscountCodeDto = new ValidateDiscountCodeDTO()
{
IsValid = true,
Message = "Discount code is valid to use"
};
var discountCode = request.DiscountCode;
var discountCodeObj = await _discountCodeRepository.GetDiscountCodeByCode(discountCode);
if (discountCodeObj == null)
{
validateDiscountCodeDto = new ValidateDiscountCodeDTO()
{
IsValid = false,
Message = "Error: Discount code is invalid to use"
};
returnValidateDiscountCode.ValidateDiscountCode = validateDiscountCodeDto;
return(returnValidateDiscountCode);
}
var discountCampaignId = discountCodeObj.DiscountCampaignId;
var discountCampaignObj = await _discountCampaignRepository.GetById(discountCampaignId);
var cartDto = request.Cart;
// Check redemptionCount
var redemptionsCount = discountCodeObj.Redemptions?.Count ?? 0;
if (discountCodeObj.MaxRedeem == redemptionsCount)
{
validateDiscountCodeDto = new ValidateDiscountCodeDTO()
{
IsValid = false,
Message = "This code already excess max redemption"
};
}
// Check expirationDate
if (discountCampaignObj.ExpirationDate < DateTime.Now)
{
validateDiscountCodeDto = new ValidateDiscountCodeDTO()
{
IsValid = false,
Message = "This code already expired"
};
}
// Check startDate
if (discountCampaignObj.StartDate > DateTime.Now)
{
validateDiscountCodeDto = new ValidateDiscountCodeDTO()
{
IsValid = false,
Message = "This campaign not yet start"
};
}
// Check discountValidations
var discountValidations = discountCampaignObj.GetSortedDiscountValidations();
var productCatId = "";
foreach (var discountValidation in discountValidations)
{
switch (discountValidation.ValueType)
{
case DiscountValidationValueType.Bill:
{
var checkBillDiscountValidation = CheckBillDiscountValidation(discountValidation, cartDto);
if (checkBillDiscountValidation != null)
{
validateDiscountCodeDto = checkBillDiscountValidation;
}
break;
}
case DiscountValidationValueType.ProductCat:
{
productCatId = CheckProductCategoryValidation(discountValidation);
break;
}
case DiscountValidationValueType.Quantity:
{
var checkQuantityValidation = CheckQuantityValidation(discountValidation, cartDto, productCatId);
if (checkQuantityValidation != null)
{
validateDiscountCodeDto = checkQuantityValidation;
}
break;
}
case DiscountValidationValueType.SpendingAmount:
{
var checkSpendingAmountValidation = CheckSpendingAmountValidation(discountValidation, cartDto, productCatId);
if (checkSpendingAmountValidation != null)
{
validateDiscountCodeDto = checkSpendingAmountValidation;
}
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
// Return
returnValidateDiscountCode.ValidateDiscountCode = validateDiscountCodeDto;
return(returnValidateDiscountCode);
}
public override async Task RemoveStreamerStream(StringValue request, IServerStreamWriter <StreamerClient> responseStream, ServerCallContext context)
{
var cancellationToken = new CancellationTokenSource();
_loginService.AddRemoveStreamerObserver(request.Value, responseStream, cancellationToken);
Task t = Task.Run(() =>
{
do
{
Task.Delay(1000).Wait();
} while (!cancellationToken.IsCancellationRequested && !context.CancellationToken.IsCancellationRequested);
});
await t;
}
public override async Task <GetAlphaResponse> GetAlpha(GetAlphaRequest request, ServerCallContext context)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
logger.LogInformation(request.ToString());
var data = Enumerable
.Range(1, 10)
.Select(x => $"record_{x}")
.ToArray();
var response = new GetAlphaResponse
{
Id = request.Id,
Data = { data }
};
await Task.Delay(50);
logger.LogInformation(response.ToString());
return(response);
}
public override async Task GetRoles(GetRolesRequest request, IServerStreamWriter <RoleResponse> responseStream, ServerCallContext context)
{
List <RoleResponse> roles = _roleManager.GetRoles();
foreach (var role in roles)
{
await responseStream.WriteAsync(role);
}
}
