protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
// Address Enrollments Client Side Stream
var userAddress = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = Konstants.AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
using (var stream = _addressClient.AddAddressEnrollments())
{
foreach (string enrollmentType in Konstants.AddressConstants.EnrollmentTypes)
{
userAddress.Enrollment = enrollmentType;
await stream.RequestStream.WriteAsync(userAddress);
}
await stream.RequestStream.CompleteAsync();
await stream;
WriteLine($"Sent All");
}
// await Task.Delay(1000, stoppingToken);
await Task.Delay(_config.GetValue <int>("RPCService:DelayInterval"), stoppingToken);
}
}
public override async Task <AddAddressResponse> AddAddress(AddAddressRequest request, ServerCallContext context)
{
_logger.Log(LogLevel.Debug, "Request Received for AddressBookService::AddAddress");
var addAddressResponse = new AddAddressResponse
{
Message = "success"
};
var address = new Address
{
StudentId = Guid.Parse(request.StudentId),
Name = request.Name,
FullAddress = request.FullAddress,
Enrollment = request.Enrollment,
EnrollmentStatus = Constants.AddressConstants.EnrollmentStatus[RandomNumberGenerator.GetRandomValue(1, 4)]
};
var newAddress = await _addressBll.AddAddress(address);
addAddressResponse.Id = newAddress.Id.ToString();
_logger.Log(LogLevel.Debug, "Returning the results from AddressBookService::AddProfessor");
return(addAddressResponse);
}
public async Task <CrabEditClientResult <CrabSubaddressId> > AddSubaddressToCrab(
AddAddressRequest request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var addCrabSubaddressResponse = await _client.Add(
new AddSubaddress
{
StreetNameId = request.StreetNameId.AsIdentifier().Map(IdentifierMappings.StreetNameId),
HouseNumber = request.HouseNumber,
BoxNumber = request.BoxNumber,
PostalCode = request.PostalCode.AsIdentifier().Map(IdentifierMappings.PostalCode),
Status = request.Status.AsIdentifier().Map(IdentifierMappings.AddressStatus),
OfficiallyAssigned = request.OfficiallyAssigned,
Position = MapPosition(request.Position)
},
cancellationToken);
return(CrabEditClientResult <CrabSubaddressId>
.From(
addCrabSubaddressResponse,
identifier => new CrabSubaddressId(addCrabSubaddressResponse.AddressId)));
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
var userAddress = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = Constants.AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
try
{
var newAddress = await _client.AddAddressAsync(userAddress);
Console.WriteLine($"Address Data with Id: {newAddress.Id}");
}
catch (RpcException rpcError)
{
_logger.LogError($"Error received from Server. {rpcError.Message} {rpcError.Trailers}");
}
await Task.Delay(_config.GetValue <int>("RPCService:DelayInterval"), stoppingToken);
}
}
private async Task WhenIAddTheAddress()
{
_request = Fixture.Build <AddAddressRequest>()
.With(x => x.UserId, _userId)
.With(x => x.PostCode, Fixture.Create <string>().Substring(0, 10))
.With(x => x.Number, Math.Abs(Fixture.Create <int>()))
.Create();
_replay = await Client.AddAddressAsync(_request);
}
public static void CopyToEntity(ConsumerAddress address, AddAddressRequest request)
{
address.ConsID = request.user_id;
address.Address = request.user_address;
address.RegionName = request.region_name;
address.PostalCode = request.postal_code;
address.AdditionalInfo = request.more_info;
address.IsDefault = Convert.ToBoolean(request.is_default);
address.Latitude = request.user_latitude;
address.Longitude = request.user_longitude;
}
private async Task WhenITryToAddAddress()
{
_request = Fixture.Build <AddAddressRequest>()
.With(x => x.UserId, _userId)
.With(x => x.Number, _number)
.With(x => x.Line, _line)
.With(x => x.PostCode, _postCode)
.Create();
_replay = await Client.AddAddressAsync(_request);
}
public async Task <HttpResponseMessage> Add(AddAddressRequest request)
{
try
{
var response = _serviceAddress.Add(request);
return(await ResponseAsync(response, _serviceAddress));
}
catch (Exception ex)
{
return(await ResponseExceptionAsync(ex));
}
}
public async Task <bool> AddAddressAsync(AddAddressRequest request)
{
var tlProvider = await _tlProvider.GetFirstOrDefaultAsync(p => p.UkPrn == request.Ukprn && p.IsActive);
if (tlProvider == null)
{
_logger.LogWarning(LogEvent.NoDataFound, $"Provider not found. ProviderUkprn = {request.Ukprn}. Method: AddAddressAsync({request})");
return(false);
}
var providerAddress = _mapper.Map <TlProviderAddress>(request, opt => opt.Items["providerId"] = tlProvider.Id);
return(await _tlProviderAddress.CreateAsync(providerAddress) > 0);
}
public ResponseDto AddAddress(AddAddressRequest request)
{
ResponseDto response = new ResponseDto();
Consumer consumer = null;
response.has_resource = 0;
try
{
using (UserDao dao = new UserDao())
{
consumer = GetAuthUser(dao, request.user_id, request.auth_token, true);
if (consumer == null)
{
MakeNouserResponse(response);
return(response);
}
ConsumerAddress address = new ConsumerAddress();
address.ConsID = request.user_id;
UsersHelper.CopyToEntity(address, request);
address.CreatedDate = DateTime.Now;
address.UpdatedDate = address.CreatedDate;
address.StatusID = 1;
if (consumer.ConsumerAddresses.Count == 0)
{
address.IsDefault = true;
}
else
{
address.IsDefault = Convert.ToBoolean(request.is_default);
if (Convert.ToBoolean(request.is_default))
{
foreach (var item in consumer.ConsumerAddresses)
{
item.IsDefault = false;
}
dao.Update(consumer);
}
}
dao.AddAddress(address);
response.code = 0;
response.message = MessagesSource.GetMessage("addr.added");
return(response);
}
}
catch (Exception ex)
{
response.MakeExceptionResponse(ex);
}
return(response);
}
public async Task <IActionResult> AddAddress(
[FromServices] ICommandHandlerResolver bus,
[FromServices] AddressCrabEditClient editClient,
[FromServices] Func <IAddresses> getAddresses,
[FromBody] AddAddressRequest request,
CancellationToken cancellationToken)
{
// TODO: Turn this into proper VBR API Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var crabAddAddress = await AddToCrab(editClient, request, cancellationToken);
var addressId = crabAddAddress.Result;
// todo: add command implementation for BoxNumber
var command = new RegisterAddress(
addressId,
StreetNameId.CreateForPersistentId(request.StreetNameId.AsIdentifier().Map(IdentifierMappings.StreetNameId)),
PostalCode.CreateForPersistentId(request.PostalCode.AsIdentifier().Map(IdentifierMappings.PostalCode)),
new HouseNumber(request.HouseNumber),
new BoxNumber(request.BoxNumber));
var position = await bus.Dispatch(
Guid.NewGuid(),
command,
GetMetadata(),
cancellationToken);
// Because we don't use the addressId as an identifier, we are stuck with the mess of retrieving our aggregate
// and getting the surrogate identifier from it.... PersistentLocalIdentifier
var addresses = getAddresses();
var address = await addresses.GetOptionalAsync(addressId, cancellationToken);
if (!address.HasValue)
{
throw new ApiException("Er is een fout opgetreden.", StatusCodes.Status500InternalServerError);
}
return(CreatedWithPosition(
$"/v1/adressen/{address.Value.PersistentLocalId}",
position,
crabAddAddress.ExecutionTime));
}
public async Task <IActionResult> AddAddresses([FromRoute] string id, [FromBody] AddAddressRequest address)
{
_logger.LogInformation("Getting user phone");
try
{
var result = await _service.AddAddressAsync(id, address.Line, address.Number, address.PostCode)
.ConfigureAwait(false);
return(StatusCode(result.StatusCode, result.Value));
}
catch (Exception e)
{
_logger.LogCritical(e, "Error to get user phone");
return(StatusCode(HttpStatusCode.ServiceUnavailable, "UserService down"));
}
}
/// <summary>
/// Adds a new member address.
/// </summary>
/// <param name="name">the name of the address</param>
/// <param name="address">the address json</param>
/// <returns>the created address record</returns>
public Task <AddressRecord> AddAddress(string name, Address address)
{
var signer = cryptoEngine.CreateSigner(Level.Low);
var request = new AddAddressRequest
{
Name = name,
Address = address,
AddressSignature = new Signature
{
MemberId = MemberId,
KeyId = signer.GetKeyId(),
Signature_ = signer.Sign(address)
}
};
return(gateway(authenticationContext()).AddAddressAsync(request)
.ToTask(response => response.Address));
}
public async Task Then_Returns_Expected_Results(AddAddressRequest request, bool expectedResult)
{
await WhenAsync(request);
var actualAddress = await DbContext.TlProviderAddress.Where(p => p.TlProvider.UkPrn == request.Ukprn && p.TlProvider.IsActive && p.IsActive).OrderByDescending(p => p.CreatedOn).FirstOrDefaultAsync();
_actualResult.Should().Be(expectedResult);
if (expectedResult)
{
actualAddress.DepartmentName.Should().Be(request.DepartmentName);
actualAddress.OrganisationName.Should().Be(request.OrganisationName);
actualAddress.AddressLine1.Should().Be(request.AddressLine1);
actualAddress.AddressLine2.Should().Be(request.AddressLine2);
actualAddress.Town.Should().Be(request.Town);
actualAddress.Postcode.Should().Be(request.Postcode);
}
}
public override async Task <AddAddressResponse> AddAddress(AddAddressRequest request, ServerCallContext context)
{
_logger.Log(LogLevel.Debug, "Request Received for AddressBookService::AddAddress");
var addAddressResponse = new AddAddressResponse
{
Message = "success"
};
var address = _mapper.Map <Address>(request);
var newAddress = await _addressBll.AddAddress(address);
addAddressResponse.Id = newAddress.Id.ToString();
_logger.Log(LogLevel.Debug, "Returning the results from AddressBookService::AddProfessor");
return(addAddressResponse);
}
public async Task <IActionResult> Add([FromBody] AddAddressRequest addAddressRequest)
{
try
{
//request validation should be here
// ...
var command = new AddAddressCommand(addAddressRequest.Name, addAddressRequest.City, addAddressRequest.Street);
var result = await _mediator.Send(command);
return(CreatedAtAction(nameof(this.GetById), new { id = result.Id }));
}
catch (Exception e)
{
return(BadRequest(new ErrorResponse()
{
ShortInfo = e.Message, AdditionalInfo = e.StackTrace
}));
}
}
public override async Task <AddAddressReplay> AddAddress(AddAddressRequest request, ServerCallContext context)
{
var operation = _provider.GetRequiredService <AddressAddOperation>();
var mapper = _provider.GetRequiredService <IMapper <Result, AddAddressReplay> >();
if (Guid.TryParse(request.UserId, out var userId))
{
var result = await operation.ExecuteAsync(new AddressAdd
{
UserId = userId,
Number = request.Number,
Line = request.Line,
PostCode = request.PostCode
});
return(mapper.Map(result));
}
return(mapper.Map(DomainError.UserError.InvalidUserId));
}
private static async Task <CrabEditClientResult <AddressId> > AddToCrab(
AddressCrabEditClient editClient,
AddAddressRequest request,
CancellationToken cancellationToken)
{
if (request.BoxNumber.IsNullOrWhiteSpace())
{
var addHouseNumberResult = await editClient.AddHouseNumberToCrab(request, cancellationToken);
return(new CrabEditClientResult <AddressId>(
AddressId.CreateFor(addHouseNumberResult.Result),
addHouseNumberResult.ExecutionTime));
}
var addSubaddressResult = await editClient.AddSubaddressToCrab(request, cancellationToken);
return(new CrabEditClientResult <AddressId>(
AddressId.CreateFor(addSubaddressResult.Result),
addSubaddressResult.ExecutionTime));
}
public override async Task <AddAddressResponse> AddAddress(AddAddressRequest request, ServerCallContext context)
{
_logger.Log(LogLevel.Debug, "Request Received for AddressBookService::AddAddress");
var addAddressResponse = new AddAddressResponse
{
Message = "success"
};
if (request.Enrollment == "Library Usage")
{
var trailers = new Metadata()
{
{ "Field", "Enrollment" },
{ "Message", "Bank enrollment is stopped temporarily" }
};
throw new RpcException(new Status(StatusCode.PermissionDenied, "Library Usage enrollment is stopped temporarily"), trailers);
}
// TODO: Technical Debt
var address = new Address
{
StudentId = Guid.Parse(request.StudentId),
Name = request.Name,
FullAddress = request.FullAddress,
Enrollment = request.Enrollment,
EnrollmentStatus = Constants.AddressConstants.EnrollmentStatus[RandomNumberGenerator.GetRandomValue(1, 4)]
};
var newAddress = await _addressBll.AddAddress(address);
addAddressResponse.Id = newAddress.Id.ToString();
_logger.Log(LogLevel.Debug, "Returning the results from AddressBookService::AddProfessor");
return(addAddressResponse);
}
public AddAddressResponse Add(AddAddressRequest request)
{
if (request == null)
{
AddNotification("SearchAddressRequest", "request inválido");
return(null);
}
var address = new Address(request.ZipCode, request.PublicPlace, request.Neighborhood,
request.State,
request.Locality,
request.Gia,
request.Ibge,
request.Complement
);
if (this.IsValid())
{
return(null);
}
return((AddAddressResponse)_repositoryAddress.Adicionar(address));
}
public override void Setup()
{
_tokenServiceClient = Substitute.For <ITokenServiceClient>();
_configuration = new ResultsAndCertificationConfiguration
{
ResultsAndCertificationInternalApiSettings = new ResultsAndCertificationInternalApiSettings {
Uri = "http://tlevel.api.com"
}
};
_mockHttpResult = true;
_model = new AddAddressRequest
{
Ukprn = 987456123,
DepartmentName = "Test dept",
AddressLine1 = "Line1",
AddressLine2 = "Line2",
Town = "town",
Postcode = "xx1 1yy",
PerformedBy = "Test User"
};
}
public async Task <bool> AddAddressAsync(AddAddressRequest request)
{
return(await _providerAddressService.AddAddressAsync(request));
}
static async Task Main(string[] args)
{
string response = "Y";
_config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json").Build();
// gRPC Clients
CollegeServiceClient CollegeClient = CollegeServiceClientHelper.GetCollegeServiceClient(_config["RPCService:ServiceUrl"]);
AddressBookServerClient AddressClient = AddressServiceClientHelper.GetAddressBookServerClient(_config["RPCService:ServiceUrl"]);
// Address Enrollments Client Side Stream
var userAddress = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = Konstants.AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
using (var stream = AddressClient.AddAddressEnrollments())
{
foreach (string enrollmentType in Konstants.AddressConstants.EnrollmentTypes)
{
userAddress.Enrollment = enrollmentType;
await stream.RequestStream.WriteAsync(userAddress);
}
await stream.RequestStream.CompleteAsync();
await stream;
WriteLine($"Sent All");
}
/*
* WriteLine("\n\nCreating New Professor ...");
* while (response == "Y")
* {
* // Add New Professor
* AddProfessorRequest professorNew = GenerateNewProfessor();
*
* var newlyAddedProfessor = await Client.AddProfessorAsync(professorNew);
* WriteLine($"\n\nNew Professor Added with Professor Id: {newlyAddedProfessor.ProfessorId}");
*
* WriteLine("\n\nDo you want to create New Professor: {Y/N}");
* response = ReadKey().KeyChar.ToString().ToUpper();
* }
*/
response = "Y";
while (response == "Y")
{
WriteLine("\n\nPlease enter a Professor Id: ");
var professorId = ReadLine();
// Retrieve Single Row
var professorRequest = new GetProfessorRequest {
ProfessorId = professorId
};
var professor = await CollegeClient.GetProfessorByIdAsync(professorRequest);
DisplayProfessorDetails(professor);
WriteLine("\n\nDo you want to Lookup a Professor: {Y/N}");
response = ReadKey().KeyChar.ToString().ToUpper();
}
// Address Service gRPC
var userAddress1 = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = Konstants.AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
var newAddress = await AddressClient.AddAddressAsync(userAddress1);
WriteLine($"Address Data with Id: {newAddress.Id}");
/*
* response = "Y";
* while (response == "Y")
* {
* // Retrieve Multiple Rows
* var professors = await Client.GetAllProfessorsAsync(new Empty());
*
* foreach (var prof in professors.Professors)
* {
* DisplayProfessorDetails(prof);
* }
*
* WriteLine("\n\nDo you want to retrieve all professors: {Y/N}");
* response = ReadKey().KeyChar.ToString().ToUpper();
* }
*/
WriteLine("\n\nThank You for using the application. \n\nPress any key ...");
ReadKey();
}
public NegotiatedContentResult <ResponseDto> PostAddAddress([FromBody] AddAddressRequest request)
{
ResponseDto resp = _userServices.AddAddress(request);
return(Content(HttpStatusCode.OK, resp));
}
static async Task Main(string[] args)
{
_config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json").Build();
var _collegeClient = CollegeServiceClientHelper.GetCollegeServiceClient(_config["RPCService:ServiceUrl"]);
var _addressClient = AddressServiceClientHelper.GetAddressBookServerClient(_config["RPCService:ServiceUrl"]);
//**************** ADDRESS BOOK ****************//
var userAddress = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
using (var stream = _addressClient.AddAddressEnrollments())
{
foreach (string enrollmentType in AddressConstants.EnrollmentTypes)
{
userAddress.Enrollment = enrollmentType;
await stream.RequestStream.WriteAsync(userAddress).ConfigureAwait(false);
}
await stream.RequestStream.CompleteAsync().ConfigureAwait(false);
await stream;
WriteLine($"Sent All");
}
//**************** ADDRESS BOOK ****************//
/*
* DisplayHeader("Creating New Professor ...");
* NewProfessorRequest professorNew = GenerateNewProfessor();
* var newlyAddedProfessor = await _collegeClient.AddProfessorAsync(professorNew);
* WriteLine($"\n\nNew Professor Added with Professor Id: {newlyAddedProfessor.ProfessorId}");
* DisplayFooter();
*/
//DisplayHeader("Retrieve Single Row ...");
//WriteLine("\n\nPlease enter a Professor Id: ");
//var professorId = ReadLine();
//var professorRequest = new GetProfessorRequest { ProfessorId = professorId };
//var professor = await _collegeClient.GetProfessorByIdAsync(professorRequest);
//DisplayProfessorDetails(professor);
//DisplayFooter();
DisplayHeader("Retrieve All Rows ...");
var professors = await _collegeClient.GetAllProfessorsAsync(new Empty());
foreach (var prof in professors.Professors)
{
DisplayProfessorDetails(prof);
}
WriteLine("\n\nThank You for using the application. \n\nPress any key ...");
ReadKey();
}
static async Task Main(string[] args)
{
string response = "Y";
_config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json").Build();
// gRPC Clients
CollegeServiceClient CollegeClient = CollegeServiceClientHelper.GetCollegeServiceClient(_config["RPCService:ServiceUrl"]);
AddressBookServerClient AddressClient = AddressServiceClientHelper.GetAddressBookServerClient(_config["RPCService:ServiceUrl"]);
/*
* var cts = new CancellationTokenSource(TimeSpan.FromSeconds(50));
*
* using var replies = AddressClient.GetWeatherStream(new Empty(), cancellationToken: cts.Token);
*
* try
* {
* await foreach (var weatherData in replies.ResponseStream.ReadAllAsync(cancellationToken: cts.Token))
* {
* Console.WriteLine($"{weatherData.DateTimeStamp.ToDateTime():s} | {weatherData.Summary} | {weatherData.TemperatureC} C");
* }
* }
* catch (RpcException ex) when (ex.StatusCode == StatusCode.Cancelled)
* {
* Console.WriteLine("Stream cancelled.");
* }
*/
// Address Enrollments Client Request for Server Streaming.
var studentEnrollmentsRequest = new AddressEnrollmentRequest {
StudentId = "3698FAED-83A1-4700-89EE-CAFE7716833E"
};
using var studentEnrollments = AddressClient.RetrieveAddressEnrollments(studentEnrollmentsRequest);
try
{
await foreach (var studentEnrollment in studentEnrollments.ResponseStream.ReadAllAsync())
{
Console.WriteLine($"{studentEnrollment.StudentId} {studentEnrollment.Name} {studentEnrollment.Enrollment} {studentEnrollment.EnrollmentStatus}");
}
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Cancelled)
{
Console.WriteLine("Stream cancelled.");
}
// Address Enrollments Client Side Stream
var userAddress = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = Konstants.AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
using (var stream = AddressClient.AddAddressEnrollments())
{
foreach (string enrollmentType in Konstants.AddressConstants.EnrollmentTypes)
{
userAddress.Enrollment = enrollmentType;
await stream.RequestStream.WriteAsync(userAddress);
}
await stream.RequestStream.CompleteAsync();
await stream;
WriteLine($"Sent All");
}
/*
* WriteLine("\n\nCreating New Professor ...");
* while (response == "Y")
* {
* // Add New Professor
* AddProfessorRequest professorNew = GenerateNewProfessor();
*
* var newlyAddedProfessor = await Client.AddProfessorAsync(professorNew);
* WriteLine($"\n\nNew Professor Added with Professor Id: {newlyAddedProfessor.ProfessorId}");
*
* WriteLine("\n\nDo you want to create New Professor: {Y/N}");
* response = ReadKey().KeyChar.ToString().ToUpper();
* }
*/
response = "Y";
while (response == "Y")
{
WriteLine("\n\nPlease enter a Professor Id: ");
var professorId = ReadLine();
// Retrieve Single Row
var professorRequest = new GetProfessorRequest {
ProfessorId = professorId
};
var professor = await CollegeClient.GetProfessorByIdAsync(professorRequest);
DisplayProfessorDetails(professor);
WriteLine("\n\nDo you want to Lookup a Professor: {Y/N}");
response = ReadKey().KeyChar.ToString().ToUpper();
}
// Address Service gRPC
var userAddress1 = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = Konstants.AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
var newAddress = await AddressClient.AddAddressAsync(userAddress1);
WriteLine($"Address Data with Id: {newAddress.Id}");
/*
* response = "Y";
* while (response == "Y")
* {
* // Retrieve Multiple Rows
* var professors = await Client.GetAllProfessorsAsync(new Empty());
*
* foreach (var prof in professors.Professors)
* {
* DisplayProfessorDetails(prof);
* }
*
* WriteLine("\n\nDo you want to retrieve all professors: {Y/N}");
* response = ReadKey().KeyChar.ToString().ToUpper();
* }
*/
WriteLine("\n\nThank You for using the application. \n\nPress any key ...");
ReadKey();
}
public async Task WhenAsync(AddAddressRequest request)
{
_actualResult = await ProviderAddressService.AddAddressAsync(request);
}
// Provider Address endpoints
public async Task <bool> AddAddressAsync(AddAddressRequest request)
{
return(await PostAsync <AddAddressRequest, bool>(ApiConstants.AddAddressUri, request));
}
static async Task Main(string[] args)
{
_config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json").Build();
var _collegeClient = CollegeServiceClientHelper.GetCollegeServiceClient(_config["RPCService:ServiceUrl"]);
var _addressClient = AddressServiceClientHelper.GetAddressBookServerClient(_config["RPCService:ServiceUrl"]);
var jwtToken = new JwtAccessToken();
if (jwtToken.Expiration < DateTime.Now)
{
jwtToken = GetTokenFromAuth0();
}
var headers = new Metadata
{
{ "Authorization", $"Bearer {jwtToken.Access_Token}" }
};
DisplayHeader("Retrieve Single Row ...");
WriteLine("\n\nPlease enter a Professor Id: ");
var professorId = ReadLine();
var professorRequest = new GetProfessorRequest {
ProfessorId = professorId
};
var professor = await _collegeClient.GetProfessorByIdAsync(professorRequest, headers : headers);
DisplayProfessorDetails(professor);
DisplayFooter();
//**************** ADDRESS BOOK CLIENT SIDE STREAMING ****************//
var userAddress = new AddAddressRequest
{
StudentId = Guid.NewGuid().ToString(), /* To Be replaced with Students's Id*/
Name = NameGenerator.GenerateName(12),
FullAddress = AddressGenerator.GenerateAddress(),
Enrollment = AddressConstants.EnrollmentTypes[RandomNumberGenerator.GetRandomValue(1, 4)]
};
using (var stream = _addressClient.AddAddressEnrollments())
{
foreach (string enrollmentType in AddressConstants.EnrollmentTypes)
{
userAddress.Enrollment = enrollmentType;
await stream.RequestStream.WriteAsync(userAddress).ConfigureAwait(false);
}
await stream.RequestStream.CompleteAsync().ConfigureAwait(false);
await stream;
WriteLine($"Sent All");
}
//**************** ADDRESS BOOK CLIENT SIDE STREAMING ****************//
//**************** ADDRESS BOOK SERVER SIDE STREAMING ****************//
var studentEnrollmentsRequest = new AddressEnrollmentRequest
{
StudentId = "62b76fc7-46d9-4d1c-a246-7f4083a87634"
};
using var studentEnrollments = _addressClient
.RetrieveAddressEnrollments(studentEnrollmentsRequest);
try
{
await foreach (var studentEnrollment in studentEnrollments.ResponseStream.ReadAllAsync())
{
WriteLine($"{studentEnrollment.StudentId} | {studentEnrollment.Name} | {studentEnrollment.Enrollment} | {studentEnrollment.EnrollmentStatus}");
}
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Cancelled)
{
Console.WriteLine("Stream cancelled.");
}
//**************** ADDRESS BOOK SERVER SIDE STREAMING ****************//
/*
* DisplayHeader("Creating New Professor ...");
* NewProfessorRequest professorNew = GenerateNewProfessor();
* var newlyAddedProfessor = await _collegeClient.AddProfessorAsync(professorNew);
* WriteLine($"\n\nNew Professor Added with Professor Id: {newlyAddedProfessor.ProfessorId}");
* DisplayFooter();
*/
//DisplayHeader("Retrieve Single Row ...");
//WriteLine("\n\nPlease enter a Professor Id: ");
//var professorId = ReadLine();
//var professorRequest = new GetProfessorRequest { ProfessorId = professorId };
//var professor = await _collegeClient.GetProfessorByIdAsync(professorRequest);
//DisplayProfessorDetails(professor);
//DisplayFooter();
DisplayHeader("Retrieve All Rows ...");
var professors = await _collegeClient.GetAllProfessorsAsync(new Empty());
foreach (var prof in professors.Professors)
{
DisplayProfessorDetails(prof);
}
WriteLine("\n\nThank You for using the application. \n\nPress any key ...");
ReadKey();
}
