public async Task <ActionResult <Events> > GetEvents()
{
var response = await _client.RequestAsync <GetEvents, Events>(new GetEvents(), default(Guid),
cfg => cfg.WithExchange(ex => ex.WithName("Queries")).WithRoutingKey("getevents.#").WithReplyQueue(q => q.WithName(nameof(GetEvents))));
return(response);
}
// Get a profile from a UserID
public async Task <Profile> GetProfileFromAccountId(Guid id)
{
var profileData = (await _queue.RequestAsync <ProfileRequestMessage, ResultMessage>(
new ProfileRequestMessage {
UserAccountId = id,
}
)).data as ProfileData;
Profile p = new Profile();
p.Id = profileData.Id;
p.Username = profileData.Username;
p.TrainerCode = profileData.TrainerCode;
p.Level = profileData.Level;
p.TeamId = profileData.TeamId;
p.Gender = profileData.Gender;
p.FeaturedPokemon = new List <Guid>();
p.FeaturedPokemon.Add(profileData.FeaturedPokemon1);
p.FeaturedPokemon.Add(profileData.FeaturedPokemon2);
p.FeaturedPokemon.Add(profileData.FeaturedPokemon3);
p.FeaturedBadges = new List <Guid>();
p.FeaturedBadges.Add(profileData.FeaturedBadge1);
p.FeaturedBadges.Add(profileData.FeaturedBadge2);
p.FeaturedBadges.Add(profileData.FeaturedBadge3);
p.FeaturedBadges.Add(profileData.FeaturedBadge4);
p.FeaturedBadges.Add(profileData.FeaturedBadge5);
return(p);
}
public async Task <IActionResult> Katedra([FromBody] KatedraRequest req)
{
var response = await _busClient.RequestAsync <KatedraRequest, KatedraResponse>(req);
_logger.LogInformation($"Katedra searched - '{req.SearchText}' - {response.Katedry.Count}");
return(Ok(JsonConvert.SerializeObject(response)));
}
public async Task <AccountViewModel> CreateRecruiter([FromBody] CreateRecruiterModel bindingModel)
{
var account = bindingModel.CreateRecruiterModelToAccountModel();
if (account == null || !ModelState.IsValid)
{
throw new CustomException(Errors.INVALID_REGISTRATION_DATA, Errors.INVALID_REGISTRATION_DATA_MSG);
}
account.AccountPermissions = new List <Models.AccountPermission>()
{
new Models.AccountPermission
{
PermissionId = PermissionsList.RECRUITER_PERMISSION
}
};
account = await _accountService.CreateAsync(account, bindingModel.Password);
try
{
//publish a recruiter account is created message to rabbit mq bus and wait for response
var response = await _rawRabbitBus.RequestAsync <RecruiterAccountCreated, RpcResult>(new RecruiterAccountCreated
{
Id = account.Id,
Email = account.Email,
PhoneNumber = account.PhoneNumber,
FirstName = bindingModel.FirstName,
LastName = bindingModel.LastName,
Gender = bindingModel.Gender,
Status = account.Status
});
if (!response.Success)
{
// account created but profile creating has an error, should be log and check
if (!string.IsNullOrEmpty(response.Error))
{
throw new CustomException(response.Error);
}
}
}
catch (System.Exception)
{
//got unhandle exception while creating recruiter profile, should be logs and correct consistency between 2 server
throw;
}
var viewModel = account.ToViewModel();
return(viewModel);
}
public async Task <IActionResult> Jwt([FromBody] JwtRequest jwtrq)
{
var response = await _busClient.RequestAsync <LoginRequest, LoginResponse>(new LoginRequest
{
IdToken = jwtrq.idtoken
});
_logger.LogInformation(response.Success
? $"Successfully generated JWT '{response.Response}' for GoogleTokenId '{jwtrq.idtoken?.Substring(0, 8)}...'"
: $"JWT could not be generated for GoogleTokenId '{jwtrq.idtoken?.Substring(0, 8)}...'");
return(Ok(JsonConvert.SerializeObject(response)));
}
public async Task <string> TestEvent()
{
Action <IRequestConfigurationBuilder> requestBuilder = (ctx) => ctx.WithExchange(xfg => xfg.WithName("testwebapi")); //.WithRoutingKey("mymessage"));
var response = await _client.RequestAsync <BasicMessage, BasicResponse>(new BasicMessage { Prop = "FROM FIRST" }, configuration : requestBuilder);
return(response.Result);
}
public async Task <string> GetAsync(int id)
{
_logger.LogInformation("Requesting Value with id {valueId}", id);
var response = await _busClient.RequestAsync <ValueRequest, ValueResponse>(new ValueRequest { Value = id });
return(response.Value);
}
public async Task <IActionResult> Get()
{
var messageContext = new MessageContext
{
Source = Request.GetDisplayUrl(),
ExecutionId = Guid.NewGuid().ToString()
};
var globalExecutionId = Guid.NewGuid().ToString();
_logger.LogInformation($"ExecutionId: {messageContext.ExecutionId}");
var response = await _busClient.RequestAsync <HelloCommand, CommandResponse <HelloCommandResponse> >(new HelloCommand
{
CommandId = Guid.NewGuid()
}, options =>
{
options.UseMessageContext(messageContext);
});
_logger.LogInformation($"Response: {JsonConvert.SerializeObject(response)}");
await _busClient.PublishAsync(new HelloEvent
{
EventId = Guid.NewGuid()
}, options =>
{
options.UseMessageContext(messageContext);
});
return(Ok());
}
public static void Main(string[] args)
{
IBusClient client = RawRabbitFactory.CreateSingleton(new RawRabbitOptions()
{
ClientConfiguration = ConnectionStringParser.Parse("guest:guest@localhost:5672/")
});
// var client = RabbitHutch.CreateBus("host=localhost;username=guest;password=guest");
Console.Out.WriteLine($"Created client. Press enter to start.");
Console.ReadLine();
var memory = new List <long>();
for (var i = 0; i < 10000; i++)
{
if ((i % 1000) == 0)
{
Console.Out.WriteLine($"Paused at iteration: {i}. Press enter to GC.Collect() and continue.");
Console.ReadLine();
memory.Add(GC.GetTotalMemory(false));
GC.Collect();
}
var result = client.RequestAsync <ValueRequest, ValueResponse>(new ValueRequest {
Value = i
}).Result;
}
Console.Out.WriteLine(string.Join(",", memory));
Console.Out.WriteLine("Finished.");
Console.ReadLine();
}
private async Task CreateProfile(UserCreateMessage message, MessageContext context)
{
// Get Pokemon
Func <int, Task <ResultMessage> > getByPokedex = (int num) =>
_queue.RequestAsync <PokemonRequestMessage, ResultMessage>(
new PokemonRequestMessage {
PokedexNumber = num
});
var pokemonResults = (await Task.WhenAll(new Task <ResultMessage>[] {
getByPokedex(1),
getByPokedex(2),
getByPokedex(3),
})).Select(result => result.data as PokemonData).ToArray();
var team = await _queue.RequestAsync <TeamRequestMessage, ResultMessage>(
new TeamRequestMessage {
Name = "Mystic",
}
);
var profile = new PogoProfile
{
Id = Guid.NewGuid(),
UserAccountId = message.Id,
PogoUsername = message.Username, //"anonymous",
PogoLevel = 1,
PogoTrainerCode = "0000 0000 0000",
PogoTeamId = (team.data as TeamData).Id,
PlayerGender = Gender.None,
FeaturedPokemon1 = pokemonResults[0].Id,
FeaturedPokemon2 = pokemonResults[1].Id,
FeaturedPokemon3 = pokemonResults[2].Id,
FeaturedBadge1 = Guid.Empty,
FeaturedBadge2 = Guid.Empty,
FeaturedBadge3 = Guid.Empty,
FeaturedBadge4 = Guid.Empty,
FeaturedBadge5 = Guid.Empty,
};
using (var scope = _scopeFactory.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <ProfileServiceDbContext>();
await dbContext.AddAsync(profile);
await dbContext.SaveChangesAsync();
}
}
public void OrderListMessageTest()
{
OrderList orderList = new OrderList();
orderList.RestaurantId = 1;
var result = bus.RequestAsync <OrderList, FDP.OrderService.MessageDirectory.Response.OrderList>(orderList).Result;
}
public Task <string> GetAsync(int id)
{
_logger.LogInformation("Requesting Value with id {valueId}", id);
return(_busClient
.RequestAsync <ValueRequest, ValueResponse>(new ValueRequest {
Value = id
})
.ContinueWith(tResponse => tResponse.Result.Value));
}
/// <summary>
/// Publish a query.
/// This is a synchronous RPC call.
/// If no subscribers answer for a number of seconds, then a timeout exception will be thrown.
/// </summary>
/// <typeparam name="TQuery">The query type</typeparam>
/// <returns>The returned value.</returns>
public static string PublishQuery <TQuery>(this IBusClient bus, TQuery query)
where TQuery : class, IQuery
{
return(bus.RequestAsync <TQuery, string>(
query,
configuration: config =>
{
config.WithExchange(exchange => exchange.WithName(QueryExchangeName));
config.WithRoutingKey(typeof(TQuery).Name);
})
.Result);
}
public async Task <IActionResult> Load()
{
var response = await _busClient.RequestAsync <UserRequest, UserResponse>(new UserRequest
{
UserId = Guid.Parse(User.Identity.Name)
});
var jsonResp = JsonConvert.SerializeObject(response);
_logger.LogInformation($"User requested - '{User.Identity.Name}' - {(response.Success ? "SUCCESS" : "FAIL")}");
return(Ok(jsonResp));
}
public APIGatewayMutation(IBusClient queue, QueueHelpers helpers)
{
// This field allows the client to update the current user's account
// according to the token they are using.
FieldAsync <ProfileType>(
"updateMe",
// As argument is a partial Profile object, see the
// ProfileInputType class for details
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ProfileInputType> > {
Name = "profile"
}
),
resolve: async context =>
{
// Using the token in the context, authenticate the user and
// get their UserId
Guid userId = (await helpers.AuthenticateFromContext(context)).UserId;
// Get the ProfileInputType argument as a Dictionary
var newProfile = context.Arguments["profile"] as Dictionary <string, object>;
// Helper function for getting a value from the argument, or
// null if it isn't defined
Func <string, object> getOrNull = prop => newProfile.ContainsKey(prop) ? newProfile[prop] : null;
// Helper function for getting a Guid of the profile or null
Func <string, Guid?> maybeGuid = field => getOrNull(field) != null
? (Guid?)Guid.Parse(newProfile[field] as string)
: null;
// Get the Profile ID of the account based on the UserId we
// got earlier
Guid id = (await helpers.GetProfileFromAccountId(userId)).Id;
// Make a request to update the Profile with the new values.
// Anything that is null won't be updated by the handler of
// the message.
var result = await queue.RequestAsync <ProfileUpdateRequestMessage, ResultMessage>(
new ProfileUpdateRequestMessage {
Id = id,
PogoUsername = getOrNull("username") as string,
PogoTeamId = maybeGuid("teamId"),
PogoTrainerCode = getOrNull("trainerCode") as string,
Gender = getOrNull("gender") as int?,
PogoLevel = getOrNull("level") as int?,
FeaturedPokemon1 = maybeGuid("featuredPokemon1"),
FeaturedPokemon2 = maybeGuid("featuredPokemon2"),
FeaturedPokemon3 = maybeGuid("featuredPokemon3"),
}
);
// If the response doesn't have the status Ok, the data
// property is an exception object, so we just throw that
if (result.status != ResultMessage.Status.Ok)
{
throw (Exception)result.data;
}
// Get the profile again so we have the updated values and
// return it so the client can get fields from it
return(await helpers.GetProfileFromAccountId(userId));
}
);
}
private async Task executeLegislatura()
{
var response = await _busClient.RequestAsync <LegislaturaRequest, LegislaturaResponse>(new LegislaturaRequest { Message = "Requisição Hangfire" });
Console.WriteLine(response.Message);
}
public APIGatewayQuery(IBusClient queue, QueueHelpers helpers)
{
// The 'me' field allows the client to get the details of the
// current profile based on the token.
FieldAsync <ProfileType>(
"me",
resolve: async context =>
{
// Authenticate the user with their token
var userId = (await helpers.AuthenticateFromContext(context)).UserId;
// Get the profile object based on the UserId we got from
// the token
var thing = await helpers.GetProfileFromAccountId(userId);
return(thing);
}
);
// Allow the client to query any profile by its ID, UserID, or username
FieldAsync <ProfileType>(
"profile",
arguments: new QueryArguments(
new QueryArgument <StringGraphType> {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "useraccountid"
},
new QueryArgument <StringGraphType> {
Name = "username"
}
),
resolve: async context => {
ProfileRequestMessage message;
// Depending on which argument we got, get the Profile
if (context.HasArgument("id"))
{
message = new ProfileRequestMessage {
Id = Guid.Parse(context.GetArgument <string>("id")),
};
}
else if (context.HasArgument("useraccountid"))
{
message = new ProfileRequestMessage {
UserAccountId = Guid.Parse(context.GetArgument <string>("useraccountid")),
};
}
else if (context.HasArgument("username"))
{
message = new ProfileRequestMessage {
Username = context.GetArgument <string>("username"),
};
}
else
{
throw new ArgumentNullException();
}
var responseTask = await queue.RequestAsync <ProfileRequestMessage, ResultMessage>(message);
var profileData = responseTask.data as ProfileData;
// map the ProfileData object to a Profile object
Profile p = new Profile();
p.Id = profileData.Id;
p.Username = profileData.Username;
p.TrainerCode = profileData.TrainerCode;
p.Level = profileData.Level;
p.TeamId = profileData.TeamId;
p.Gender = profileData.Gender;
p.FeaturedPokemon = new List <Guid>();
p.FeaturedPokemon.Add(profileData.FeaturedPokemon1);
p.FeaturedPokemon.Add(profileData.FeaturedPokemon2);
p.FeaturedPokemon.Add(profileData.FeaturedPokemon3);
return(p);
}
);
// Get a pokemon by id, name or pokedex number
FieldAsync <PokemonType>(
"pokemon",
arguments: new QueryArguments(
new QueryArgument <StringGraphType> {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "name"
},
new QueryArgument <IntGraphType> {
Name = "pokedexNumber"
}
),
resolve: async context => {
PokemonRequestMessage message;
// make the request message based on the argument we got
if (context.HasArgument("id"))
{
message = new PokemonRequestMessage {
Id = Guid.Parse(context.GetArgument <string>("id")),
};
}
else if (context.HasArgument("name"))
{
message = new PokemonRequestMessage {
Name = context.GetArgument <string>("name"),
};
}
else if (context.HasArgument("pokedexNumber"))
{
message = new PokemonRequestMessage {
PokedexNumber = context.GetArgument <int>("pokedexNumber"),
};
}
else
{
throw new ArgumentNullException();
}
var responseTask = await queue.RequestAsync <PokemonRequestMessage, ResultMessage>(message);
var pokemonData = responseTask.data as PokemonData;
return(new Pokemon {
Id = pokemonData.Id,
Name = pokemonData.Name,
PokedexNumber = pokemonData.PokedexNumber,
SpriteImageUrl = pokemonData.SpriteImageUrl,
PogoImageUrl = pokemonData.PogoImageUrl,
});
}
);
// get a team by ID
FieldAsync <TeamType>(
"team",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "id"
}),
resolve: async context => {
var responseTask = await queue.RequestAsync <TeamRequestMessage, ResultMessage>(
new TeamRequestMessage {
Id = Guid.Parse(context.GetArgument <string>("id")),
}
);
var teamData = responseTask.data as TeamData;
return(new Team {
Id = teamData.Id,
Name = teamData.Name,
Color = teamData.Color,
ImageUrl = teamData.ImageUrl,
});
}
);
// Get a badge by ID
FieldAsync <BadgeType>(
"badge",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "id"
}),
resolve: async context => {
var responseTask = await queue.RequestAsync <BadgeRequestMessage, ResultMessage>(
new BadgeRequestMessage {
Id = Guid.Parse(context.GetArgument <string>("id")),
}
);
var badgeData = responseTask.data as BadgeData;
return(new Badge {
Id = badgeData.Id,
Name = badgeData.Name,
ImageUrl = badgeData.ImageUrl,
});
}
);
// Get a pokemonType by ID
FieldAsync <PokemonTypeType>(
"pokemonType",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "id"
}),
resolve: async context => {
var responseTask = await queue.RequestAsync <PokemonTypeRequestMessage, ResultMessage>(
new PokemonTypeRequestMessage {
Id = Guid.Parse(context.GetArgument <string>("id")),
}
);
var typeData = responseTask.data as PokemonTypeData;
return(new PokemonTypeInfo {
Id = typeData.Id,
Name = typeData.Name,
});
}
);
// Get all badges
FieldAsync <ListGraphType <BadgeType> >(
"badges",
resolve: async context => {
var responseTask = await queue.RequestAsync <BadgesRequestMessage, ResultMessage>(
new BadgesRequestMessage()
);
var badgeDatas = responseTask.data as List <BadgeData>;
var badges = badgeDatas
.Select(x => new Badge {
Id = x.Id,
Name = x.Name,
ImageUrl = x.ImageUrl,
})
.ToList();
return(badges);
}
);
// get all teams
FieldAsync <ListGraphType <TeamType> >(
"teams",
resolve: async context => {
var responseTask = await queue.RequestAsync <TeamsRequestMessage, ResultMessage>(
new TeamsRequestMessage()
);
var teamDatas = responseTask.data as List <TeamData>;
var teams = teamDatas
.Select(x => new Team {
Id = x.Id,
Name = x.Name,
Color = x.Color,
ImageUrl = x.ImageUrl,
})
.ToList();
return(teams);
}
);
// get all pokemon (pluralized to pokemen)
FieldAsync <ListGraphType <PokemonType> >(
"pokemen",
resolve: async context => {
var responseTask = await queue.RequestAsync <PokemenRequestMessage, ResultMessage>(
new PokemenRequestMessage()
);
var pokemanDatas = responseTask.data as List <PokemonData>;
var pokemans = pokemanDatas
.Select(x => new Pokemon {
Id = x.Id,
Name = x.Name,
PokedexNumber = x.PokedexNumber,
SpriteImageUrl = x.SpriteImageUrl,
PogoImageUrl = x.PogoImageUrl,
})
.ToList();
return(pokemans);
}
);
// Get all pokemon types
FieldAsync <ListGraphType <PokemonTypeType> >(
"pokemonTypes",
resolve: async context => {
var responseTask = await queue.RequestAsync <PokemonTypesRequestMessage, ResultMessage>(
new PokemonTypesRequestMessage()
);
var typeDatas = responseTask.data as List <PokemonTypeData>;
var types = typeDatas
.Select(x => new PokemonTypeInfo {
Id = x.Id,
Name = x.Name,
})
.ToList();
return(types);
}
);
}
public async Task <IActionResult> Post([FromBody] CreateUserRequest request)
{
var respond = await _busClient.RequestAsync <CreateUserRequest, CreateUserRespond>(request);
return(respond.Respond);
}
/// <summary>
/// 发送请求消息
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="busClient"></param>
/// <param name="request"></param>
public static TResponse Request <TRequest, TResponse>(this IBusClient busClient, TRequest request)
where TRequest : class
where TResponse : class
{
return(busClient.RequestAsync <TRequest, TResponse>(request).GetAwaiter().GetResult());
}
public ProfileType(ContextServiceLocator ContextServiceLocator, IBusClient queue)
{
Name = "Profile";
Field <StringGraphType>("id", resolve: context => context.Source.Id.ToString());
Field(x => x.Username);
Field(x => x.Level);
Field(x => x.TrainerCode);
Field(x => x.Gender);
FieldAsync <PokemonType>(
"featuredPokemon",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "n"
}),
resolve: async context => {
var responseTask = await queue.RequestAsync <PokemonRequestMessage, ResultMessage>(
new PokemonRequestMessage {
Id = context.Source.FeaturedPokemon[context.GetArgument <int>("n")],
}
);
var pokemonData = responseTask.data as PokemonData;
return(new Pokemon {
Id = pokemonData.Id,
Name = pokemonData.Name,
PokedexNumber = pokemonData.PokedexNumber,
SpriteImageUrl = pokemonData.SpriteImageUrl,
PogoImageUrl = pokemonData.PogoImageUrl,
});
}
);
FieldAsync <ListGraphType <PokemonType> >(
"featuredPokemen",
resolve: async context => {
var responseTasks = new List <Task <ResultMessage> >();
foreach (Guid pokemon in context.Source.FeaturedPokemon)
{
responseTasks.Add(
queue.RequestAsync <PokemonRequestMessage, ResultMessage>(
new PokemonRequestMessage {
Id = pokemon,
}
)
);
}
var pokemen = new List <Pokemon>();
foreach (var result in await Task.WhenAll(responseTasks))
{
var data = result.data as PokemonData;
pokemen.Add(
new Pokemon {
Id = data.Id,
Name = data.Name,
PokedexNumber = data.PokedexNumber,
SpriteImageUrl = data.SpriteImageUrl,
PogoImageUrl = data.PogoImageUrl,
}
);
}
return(pokemen);
}
);
FieldAsync <BadgeType>(
"featuredBadge",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "n"
}),
resolve: async context => {
var responseTask = await queue.RequestAsync <BadgeRequestMessage, ResultMessage>(
new BadgeRequestMessage {
Id = context.Source.FeaturedBadges[context.GetArgument <int>("n")],
}
);
var badgeData = responseTask.data as BadgeData;
return(new Badge {
Id = badgeData.Id,
Name = badgeData.Name,
ImageUrl = badgeData.ImageUrl,
});
}
);
FieldAsync <ListGraphType <BadgeType> >(
"featuredBadges",
resolve: async context => {
var responseTasks = new List <Task <ResultMessage> >();
foreach (Guid badge in context.Source.FeaturedBadges)
{
responseTasks.Add(
queue.RequestAsync <BadgeRequestMessage, ResultMessage>(
new BadgeRequestMessage {
Id = context.Source.FeaturedBadges[context.GetArgument <int>("n")],
}
)
);
}
var badges = new List <Badge>();
foreach (var result in await Task.WhenAll(responseTasks))
{
var badgeData = result.data as BadgeData;
badges.Add(
new Badge {
Id = badgeData.Id,
Name = badgeData.Name,
ImageUrl = badgeData.ImageUrl,
});
}
return(badges);
}
);
Field <StringGraphType>("teamId", resolve: context => context.Source.TeamId.ToString());
FieldAsync <TeamType>(
"team",
resolve: async context => {
var responseTask = await queue.RequestAsync <TeamRequestMessage, ResultMessage>(
new TeamRequestMessage {
Id = context.Source.TeamId,
}
);
var teamData = responseTask.data as TeamData;
return(new Team {
Id = teamData.Id,
Name = teamData.Name,
Color = teamData.Color,
ImageUrl = teamData.ImageUrl,
});
}
);
}
