public override Task Execute(MessageData data)
{
if (BinUpdater.SoldLastMin.Count > 0)
{
var recentSold = BinUpdater.SoldLastMin.Take(40)
.Select(a => new PlayerAuctionsCommand.AuctionResult(a))
.Select(AuctionService.Instance.GuessMissingProperties)
.ToList();
return(data.SendBack(data.Create("endedAuctions", recentSold, A_MINUTE)));
}
using (var context = new HypixelContext())
{
context.Database.SetCommandTimeout(30);
var end = System.DateTime.Now;
var highVolumeIds = new System.Collections.Generic.HashSet <int>()
{
ItemDetails.Instance.GetItemIdForName("ENCHANTED_BOOK"),
ItemDetails.Instance.GetItemIdForName("GRAPPLING_HOOK"),
ItemDetails.Instance.GetItemIdForName("KISMET_FEATHER"),
};
var pages = context.Auctions.Where(a => highVolumeIds.Contains(a.ItemId) && a.End < end)
.OrderByDescending(a => a.Id)
.Select(p => new PlayerAuctionsCommand.AuctionResult(p))
.Take(100)
.ToList()
.OrderByDescending(a => a.End)
.Take(30)
.Select(AuctionService.Instance.GuessMissingProperties)
.ToList();
return(data.SendBack(data.Create("endedAuctions", pages, A_MINUTE)));
}
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
try
{
var user = data.User;
return(data.SendBack(data.Create("premiumExpiration", user?.PremiumExpires)));
} catch (Exception)
{
// no premium
return(data.SendBack(data.Create <string>("premiumExpiration", null)));
}
}
}
public override Task Execute(MessageData data)
{
ItemSearchQuery details = ItemPricesCommand.GetQuery(data);
// temporary map none (0) to any
if (details.Reforge == Reforge.None)
{
details.Reforge = Reforge.Any;
}
if (Program.LightClient && details.Start < DateTime.Now - TimeSpan.FromDays(7))
{
return(ClientProxy.Instance.Proxy(data));
}
var thread = ItemPrices.Instance.GetPriceFor(details);
var res = thread.Result;
var maxAge = A_MINUTE;
if (IsDayRange(details))
{
maxAge = A_DAY;
}
Console.WriteLine("made response");
return(data.SendBack(data.Create("itemResponse", res, maxAge)));
}
public override async Task Execute(MessageData data)
{
var details = data.GetAs <ActiveItemSearchQuery>();
if (Program.LightClient && details.Start < DateTime.Now - TimeSpan.FromDays(7))
{
await ClientProxy.Instance.Proxy(data);
return;
}
// temporary map none (0) to any
if (details.Reforge == Reforge.None)
{
details.Reforge = Reforge.Any;
}
var count = 24;
if (details.Limit < count && details.Limit > 0)
{
count = details.Limit;
}
var res = await ItemPrices.Instance.GetActiveAuctions(details);
await data.SendBack(data.Create("activeAuctions", res, A_MINUTE * 2));
}
public override async Task Execute(MessageData data)
{
var items = data.GetAs <List <PricesSyncCommand.AveragePriceSync> >()
.ConvertAll(p => p.GetBack())
.OrderBy(p => p.Date)
.ToList();
int count = 0;
ReceivedCount += items.Count;
if (items.Count == 0)
{
return;
}
using (var context = new HypixelContext())
{
var batchsize = 200;
for (int i = 0; i < items.Count / batchsize; i++)
{
await DoBatch(items.Skip(i *batchsize).Take(batchsize), count, context);
}
count = context.Prices.Count();
}
if (count > 200_000 && Environment.ProcessorCount > 9)
{
return; // break early on my dev machine
}
await data.SendBack(data.Create("pricesSync", ReceivedCount));
}
public override Task Execute(MessageData data)
{
var r = new System.Random();
using (var context = new HypixelContext())
{
var pages = context.Items
.OrderByDescending(i => i.HitCount)
.Select(i => new { Name = i.Names.FirstOrDefault(), i.Tag, i.IconUrl })
.Take(40).ToList()
.Select(i => new Result()
{
title = i.Name?.Name, url = "/item/" + i.Tag, img = i.IconUrl
})
.ToList();
pages.AddRange(context.Players
.OrderByDescending(i => i.HitCount).Select(i => new { Name = i.Name, i.UuId })
.Take(40)
.ToList()
.Select(p => new Result()
{
title = p.Name, url = "/player/" + p.UuId, img = SearchService.PlayerHeadUrl(p.UuId)
}));
return(data.SendBack(data.Create("popularSearches", pages
.OrderBy(s => r.Next()).Take(50).ToList(), A_MINUTE * 5)));
}
}
public override Task Execute(MessageData data)
{
Regex rgx = new Regex("[^a-f0-9]");
var search = rgx.Replace(data.Data, "");
using (var context = new HypixelContext()) {
var result = context.Auctions
.Include(a => a.NbtData)
.Include(a => a.Enchantments)
.Include(a => a.Bids)
.Where(a => a.Uuid == search).FirstOrDefault();
if (result == null)
{
if (Program.LightClient)
{
ClientProxy.Instance.Proxy(data);
return(Task.Delay(10000));
}
throw new CoflnetException("error", $"The Auction `{search}` wasn't found");
}
var resultJson = JSON.Stringify(result);
var maxAge = A_MINUTE;
if (result.End < DateTime.Now)
{
// won't change anymore
maxAge = A_WEEK;
}
return(data.SendBack(new MessageData("auctionDetailsResponse", resultJson, maxAge)));
}
}
public override async Task Execute(MessageData data)
{
var search = RemoveInvalidChars(data.Data);
var result = await ItemDetails.Instance.Search(search);
await data.SendBack(data.Create("itemSearch", result.Select(a => new SearchService.SearchResultItem(a)).ToList(), A_HOUR));
}
public async Task <CacheStatus> TryFromCacheAsync(MessageData request)
{
var key = GetCacheKey(request);
var responses = await GetFromRedis <CacheElement>(key);
if (responses == null)
{
return(CacheStatus.MISS);
}
if (responses.Expires < DateTime.Now)
{
// stale
return(CacheStatus.STALE);
}
var maxAgeLeft = (int)(responses.Expires - DateTime.Now).TotalSeconds;
foreach (var response in responses.Responses)
{
// adjust the cache time to when it expires on the server
response.MaxAge = maxAgeLeft;
await request.SendBack(response, false);
}
if ((responses.Expires - responses.Created).TotalSeconds / 2 > maxAgeLeft)
{
RefreshResponse(request);
return(CacheStatus.REFRESH);
}
return(CacheStatus.RECENT);
}
public override System.Threading.Tasks.Task Execute(MessageData data)
{
ItemSearchQuery details = GetQuery(data);
Console.WriteLine($"Start: {details.Start} End: {details.End}");
int hourAmount = DetermineHourAmount(details);
var fromDB = ItemPrices.Instance.GetPriceFor(details);
fromDB.Wait();
var result = new List <Result>();
result.AddRange(fromDB.Result.Prices.Select(p => new Result()
{
Count = p.Volume,
Price = (int)p.Avg,
End = p.Date
}));
var response = GroupResponseByHour(result, hourAmount);
var maxAge = 100;
if (details.Start < DateTime.Now - TimeSpan.FromDays(2))
{
maxAge = A_DAY;
}
return(data.SendBack(data.Create("itemResponse", response, maxAge)));
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var response = context.Items.Include(i => i.Names).ToList();
return(data.SendBack(new MessageData("itemSyncResponse", System.Convert.ToBase64String(MessagePack.MessagePackSerializer.Serialize(response)))));
}
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var userId = data.UserId;
var subs = context.SubscribeItem.Where(s => s.UserId == userId).ToList();
return(data.SendBack(data.Create("subscriptions", subs)));
}
}
public override async Task Execute(MessageData data)
{
var args = data.GetAs <Arguments>();
string serviceAccountEmail = "*****@*****.**";
var certificate = new X509Certificate2(@"keyfile.p12", "notasecret", X509KeyStorageFlags.Exportable);
ServiceAccountCredential credential = new ServiceAccountCredential(
new ServiceAccountCredential.Initializer(serviceAccountEmail)
{
Scopes = new[] { "https://www.googleapis.com/auth/androidpublisher" }
}.FromCertificate(certificate));
var service = new AndroidPublisherService(
new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "GooglePlay API Sample",
});
// try catch this function because if you input wrong params ( wrong token) google will return error.
//var request = service.Inappproducts.List("de.flou.hypixel.skyblock");
var request = service.Purchases.Products.Get(
args.PackageName,
args.ProductId,
args.Token);
try
{
Console.WriteLine($"Purchasing Product with id: {args.ProductId}");
var purchaseState = await request.ExecuteAsync();
//get purchase'status
Console.WriteLine(JsonConvert.SerializeObject(purchaseState));
if (((long)purchaseState.PurchaseTimeMillis / 1000).ThisIsNowATimeStamp() < DateTime.Now - TimeSpan.FromDays(7))
{
throw new CoflnetException("purchase_expired", "This purchase is older than a week and thus expired");
}
var days = int.Parse(args.ProductId.Split('_')[1]);
UserService.Instance.SavePurchase(data.User, days, purchaseState.OrderId);
}
catch (Exception e)
{
Logger.Instance.Error("Purchase failure " + e.Message);
throw new CoflnetException("purchase_failed", "Purchase failed, please contact the admin");
}
await data.SendBack(data.Create("accepted", "payment was accepted enjoy your premium", A_WEEK));
}
public override Task Execute(MessageData data)
{
var options = new PriceListOptions {
Limit = 10
};
var service = new PriceService();
StripeList <Price> prices = service.List(options);
return(data.SendBack(new MessageData("pricesResponse", JsonConvert.SerializeObject(prices), A_HOUR)));
}
public override Task Execute(MessageData data)
{
Regex rgx = new Regex("[^a-zA-Z0-9_]");
var search = rgx.Replace(data.Data, "").ToLower();
var players = PlayerSearch.Instance.Search(search, 5);
return(data.SendBack(data.Create("searchResponse", players, A_WEEK)));
return(Task.CompletedTask);
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var args = data.GetAs <Arguments>();
var userId = data.UserId;
var affected = SubscribeEngine.Instance.Unsubscribe(userId, args.Topic, args.Type).Result;
return(data.SendBack(data.Create("unsubscribed", affected)));
}
}
public override Task Execute(MessageData data)
{
var values = Enum.GetValues(typeof(ItemReferences.Reforge))
.Cast <ItemReferences.Reforge>()
.Select(ench => ench.ToString())
.ToList();
return(data.SendBack(new MessageData("getReforgesResponse",
JsonConvert.SerializeObject(values),
A_DAY
)));
}
public override Task Execute(MessageData data)
{
var uuid = data.GetAs <string>();
System.Console.WriteLine(uuid);
using (var context = new HypixelContext())
{
var auction = context.Auctions
.Where(a => a.Uuid == uuid)
.Include(a => a.NbtData)
.Include(a => a.Enchantments)
.FirstOrDefault();
if (auction == null)
{
throw new CoflnetException("auction_unkown", "not found");
}
if (Flipper.FlipperEngine.Instance.relevantAuctionIds.TryGetValue(auction.UId, out List <long> ids))
{
return(data.SendBack(data.Create("basedOnResp", context.Auctions.Where(a => ids.Contains(a.UId)).Select(a => new Response()
{
uuid = a.Uuid,
highestBid = a.HighestBidAmount,
end = a.End
}).ToList(), 120)));
}
System.Console.WriteLine($"uuid not found on id list " + Flipper.FlipperEngine.Instance.relevantAuctionIds.Count);
var result = Flipper.FlipperEngine.Instance.GetRelevantAuctions(auction, context);
result.Wait();
return(data.SendBack(data.Create("basedOnResp", result.Result.Item1
.Select(a => new Response()
{
uuid = a.Uuid,
highestBid = a.HighestBidAmount,
end = a.End
}),
A_HOUR)));
}
}
public override Task Execute(MessageData data)
{
var values = Enum.GetValues(typeof(Enchantment.EnchantmentType))
.Cast <Enchantment.EnchantmentType>()
//.Where(ench => ench != Enchantment.EnchantmentType.unknown)
.Select(ench => new Formatted(ench.ToString(), (int)ench))
.ToList();
return(data.SendBack(new MessageData("getEnchantmentsResponse",
JsonConvert.SerializeObject(values),
A_DAY
)));
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var pages = context.Auctions.OrderByDescending(a => a.Id)
.Take(30)
.Select(p => new PlayerAuctionsCommand.AuctionResult(p))
.ToList()
.Select(AuctionService.Instance.GuessMissingProperties)
.ToList();
return(data.SendBack(data.Create("newAuctions", pages, A_MINUTE)));
}
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var batchAmount = 5000;
var offset = data.GetAs <int>();
var response = context.Prices.Skip(offset).Take(batchAmount).Select(p => new AveragePriceSync(p)).ToList();
if (response.Count == 0)
{
return(Task.CompletedTask);
}
return(data.SendBack(new MessageData("pricesSyncResponse", System.Convert.ToBase64String(MessagePack.MessagePackSerializer.Serialize(response)))));
}
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var batchAmount = 5000;
var offset = data.GetAs <int>();
if (offset != 0)
{
offset -= 120; // two update batch wide overlap
}
var response = new PlayerSyncData(context.Players.Skip(offset).Take(batchAmount).ToList(), offset + batchAmount);
return(data.SendBack(new MessageData("playerSyncResponse", System.Convert.ToBase64String(MessagePack.MessagePackSerializer.Serialize(response)))));
}
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var players = context.Players
.OrderByDescending(p => p.UpdatedAt)
.Take(50)
.ToList()
.Select(p => new Response()
{
Name = p.Name, UpdatedAt = p.UpdatedAt, UuId = p.UuId
});
return(data.SendBack(data.Create("newPlayersResponse", players, A_MINUTE)));
}
}
public override async Task Execute(MessageData data)
{
var response = data.GetAs <PlayerSyncCommand.PlayerSyncData>();
var players = response.Players;
var ids = players.Select(p => p.UuId);
if (players.Count == 0)
{
return; // done
}
int count = 0;
using (var context = new HypixelContext())
{
var existingPlayers = context.Players.Where(p => ids.Contains(p.UuId));
var existing = existingPlayers.ToDictionary(p => p.UuId);
foreach (var player in players)
{
if (existing.ContainsKey(player.UuId))
{
var existingPlayer = existingPlayers.Where(p => p.UuId == player.UuId).FirstOrDefault();
if (existingPlayer.Name == null)
{
existingPlayer.Name = player.Name;
context.Update(existingPlayer);
}
continue;
}
context.Players.Add(player);
count++;
if (count % 1000 == 0)
{
await context.SaveChangesAsync();
}
}
try
{
await context.SaveChangesAsync();
}
catch (Exception e)
{
dev.Logger.Instance.Error(e, "playerSync");
}
count = context.Players.Count();
}
await data.SendBack(data.Create("playerSync", response.Offset));
}
public override Task Execute(MessageData data)
{
using (var context = new HypixelContext())
{
var items = context.Items.OrderByDescending(p => p.Id)
.Select(i => new { IconUrl = i.IconUrl, Name = i.Names.Where(n => n.Name != null && n.Name != "null").FirstOrDefault(), Tag = i.Tag })
.Where(i => i.Name != null)
.Take(50)
.ToList()
.Select(i => new Response()
{
IconUrl = i.IconUrl, Name = i.Name.Name, Tag = i.Tag
})
.ToList();
return(data.SendBack(data.Create("newItemsResponse", items, A_HOUR)));
}
}
public override Task Execute(MessageData data)
{
ItemSearchQuery details = ItemPricesCommand.GetQuery(data);
if (Program.LightClient && details.Start < DateTime.Now - TimeSpan.FromDays(7))
{
return(ClientProxy.Instance.Proxy(data));
}
// temporary map none (0) to any
if (details.Reforge == Reforge.None)
{
details.Reforge = Reforge.Any;
}
var res = ItemPrices.Instance.GetRecentAuctions(details);
return(data.SendBack(data.Create("auctionResponse", res, A_MINUTE * 2)));
}
public override Task Execute(MessageData data)
{
var flipps = Flipper.FlipperEngine.Instance.Flipps.Take(50);
try {
if (data.UserId != 0)
{
flipps = Flipper.FlipperEngine.Instance.Flipps.Skip(50).Take(50);
}
if (data.User.HasPremium)
{
flipps = Flipper.FlipperEngine.Instance.Flipps.Reverse().Skip(2).Take(50);
}
} catch (CoflnetException)
{
// no premium, continue
}
return(data.SendBack(data.Create("flips", flipps, A_MINUTE)));
}
public override async Task Execute(MessageData data)
{
var uuid = data.GetAs<string>();
var amount = (new Random()).Next(20, 999);
var userId = 1;//data.UserId;
var player = await PlayerService.Instance.GetPlayer(uuid);
if (player == default(Player))
throw new CoflnetException("unkown_player", "This player was not found");
var sub = new VerifySub(a =>
{
var code = a.StartingBid;
if(a.AuctioneerId != uuid)
code = a.Bids.Where(u => u.Bidder == uuid).Select(b => b.Amount).Where(b => b % 1000 == amount).FirstOrDefault();
Console.WriteLine("vertifying " + code);
if (code % 1000 == amount)
using (var context = new HypixelContext())
{
var user = context.Users.Where(u => u.Id == userId).FirstOrDefault();
user.MinecraftUuid = a.AuctioneerId;
context.Update(user);
context.SaveChanges();
}
});
sub.Type = SubscribeItem.SubType.PLAYER;
sub.UserId = userId;
sub.TopicId = uuid;
sub.Price = amount;
SubscribeEngine.Instance.AddNew(sub);
var response = new Response()
{
StartingBid = amount
};
await data.SendBack(data.Create("connectMc", response));
}
public override Task Execute(MessageData data)
{
Result result = new Result();
Regex rgx = new Regex("[^a-f0-9]");
var search = rgx.Replace(data.Data, "");
result.Bids.Add(new BidResult()
{
ItemName = "Loading ..."
});
result.Bids.Add(new BidResult()
{
ItemName = "This takes a minute :/"
});
result.Auctions.Add(new AuctionResult()
{
ItemName = "Loading the latest data"
});
data.SendBack(data.Create("playerResponse", result, A_HOUR));
using (var context = new HypixelContext()) {
var playerQuery = context.Players.Where(p => p.UuId == search);
var playerWithAuctions = playerQuery
// .Include (p => p.Auctions)
.First();
result.Auctions = context.Auctions
.Where(e => e.SellerId == playerWithAuctions.Id)
.Select(a => new AuctionResult(a))
.OrderByDescending(a => a.End)
.ToList();
// just the auctions for now
data.SendBack(data.Create("playerResponse", result, A_HOUR));
var playerBids = context.Bids.Where(b => b.Bidder == search)
//.Include (p => p.Auction)
.Select(b => new {
b.Auction.Uuid,
b.Auction.ItemName,
b.Auction.HighestBidAmount,
b.Auction.End,
b.Amount,
}).GroupBy(b => b.Uuid)
.Select(bid => new {
bid.Key,
Amount = bid.Max(b => b.Amount),
HighestBid = bid.Max(b => b.HighestBidAmount),
ItemName = bid.Max(b => b.ItemName),
HighestOwnBid = bid.Max(b => b.Amount),
End = bid.Max(b => b.End)
})
//.ThenInclude (b => b.Auction)
.ToList();
var aggregatedBids = playerBids
.Select(b => new BidResult()
{
HighestBid = b.HighestBid,
AuctionId = b.Key,
End = b.End,
HighestOwnBid = b.HighestOwnBid,
ItemName = b.ItemName
})
.OrderByDescending(b => b.End)
.ToList();
result.Bids = aggregatedBids;
//data.SendBack (MessageData.Create ("playerResponse", result));
// fetch full auction data
//var auctionsForBids = context.Auctions.Where(a=>result.Bids.Any(b=>b.==a.Id))
}
return(data.SendBack(data.Create("playerResponse", result, A_HOUR)));
}
public override Task Execute(MessageData data)
{
return(data.SendBack(data.Create("preview",
PreviewService.Instance.GetItemPreview(data.GetAs <string>()),
A_DAY)));
}
