private async Task SettleAuctionEntry(AuctionEntry auctionEntry)
{
if (await _lndService.SettleHodlInvoice(auctionEntry.Preimage))
{
auctionEntry.SettledAt = Utility.Utility.DateTimeToUnix(DateTime.UtcNow);
auctionEntry.State = AuctionEntryState.SETTLED;
await UpdateAuctionEntry(auctionEntry);
}
}
private async Task <AuctionEntry> UpdateAuctionEntry(AuctionEntry auctionEntry)
{
using (var context = new AuctionContext())
{
auctionEntry = context.AuctionEntries.Update(auctionEntry).Entity;
await context.SaveChangesAsync();
}
return(auctionEntry);
}
private async Task CancelAuctionEntry(AuctionEntry auctionEntry)
{
if (await _lndService.CancelHodlInvoice(auctionEntry.PaymentHash))
{
auctionEntry.CanceledAt = Utility.Utility.DateTimeToUnix(DateTime.UtcNow);
auctionEntry.State = AuctionEntryState.CANCELED;
await UpdateAuctionEntry(auctionEntry);
}
}
protected async override Task Run()
{
try
{
if (
Lua.GetReturnVal <int>(
"if AuctionFrame and AuctionFrame:IsVisible() == 1 then return 1 else return 0 end ", 0) ==
0)
{
MoveToAh();
}
else if (
Lua.GetReturnVal <int>(
"if CanSendAuctionQuery('owner') == 1 then return 1 else return 0 end ", 0) == 1)
{
if (_toScanItemList == null)
{
_toScanItemList = BuildScanItemList();
_toCancelItemList = new List <AuctionEntry>();
}
if (_toScanItemList.Count > 0)
{
AuctionEntry ae = _toScanItemList[0];
bool scanDone = ScanAh(ref ae);
_toScanItemList[0] = ae; // update
if (scanDone)
{
_toCancelItemList.Add(ae);
_toScanItemList.RemoveAt(0);
}
if (_toScanItemList.Count == 0)
{
ProfessionbuddyBot.Debug("Finished scanning for items");
}
}
else
{
if (_toCancelItemList.Count == 0)
{
_toScanItemList = null;
IsDone = true;
return;
}
if (CancelAuction(_toCancelItemList[0]))
{
_toCancelItemList.RemoveAt(0);
}
}
}
}
catch (Exception ex)
{
PBLog.Warn(ex.ToString());
}
}
public void InitializeAuction(AuctionEntry auction)
{
if (auction != null)
{
AuctionItemID = auction.Id;
Money = auction.bid == auction.buyout ? 0 : auction.bid;
MinIncrement = auction.bid == auction.buyout ? 0 : auction.GetAuctionOutBid();
Guid = ObjectGuid.Create(HighGuid.Player, auction.bidder);
}
}
private bool CancelAuction(AuctionEntry ae)
{
string lua = String.Format(CancelAuctionLuaFormat, ae.Id, MinBuyout.TotalCopper, ae.LowestBo);
var numCanceled = Lua.GetReturnVal <int>(lua, 0);
if (numCanceled > 0)
{
PBLog.Log("Canceled {0} x{1}", ae.Name, numCanceled);
}
return(true);
}
public async Task <AuctionEntry> RequestAuctionEntryInvoice(Guid auctionId, long amount, string winningMessage)
{
var auction = GetAuction(auctionId);
if (auction == null)
{
return(null);
}
var guid = Guid.NewGuid();
var auctionInvoice = new AuctionInvoice
{
Amount = amount,
AuctionId = auction.Id.ToString(),
WinningMessage = winningMessage,
AuctionEntryId = guid.ToString(),
};
var description = JsonSerializer.Serialize <AuctionInvoice>(auctionInvoice);
var expiry = (auction.Duration + auction.StartedAt) - Utility.Utility.DateTimeToUnix(DateTime.UtcNow);
if (expiry < 1)
{
return(null);
}
var invoice = await _lndService.GetHoldInvoice(amount, description, expiry);
var auctionEntry = new AuctionEntry
{
Id = guid,
State = AuctionEntryState.CREATED,
Amount = amount,
Description = description,
AuctionId = auction.Id,
PaymentHash = invoice.paymentHash,
Preimage = invoice.preImage,
PaymentRequest = invoice.payreq,
Message = winningMessage,
CreatedAt = Utility.Utility.DateTimeToUnix(DateTime.UtcNow)
};
using (var context = new AuctionContext())
{
auctionEntry = context.AuctionEntries.Add(auctionEntry).Entity;
await context.SaveChangesAsync();
}
Console.WriteLine("created auction entry {0}", auctionEntry);
return(auctionEntry);
}
private bool ScanAh(ref AuctionEntry ae)
{
bool scanned = false;
if (!_queueTimer.IsRunning)
{
string lua = string.Format("QueryAuctionItems(\"{0}\" ,nil,nil,nil,nil,nil,{1}) return 1",
ae.Name.ToFormatedUTF8(), _page);
Lua.GetReturnVal <int>(lua, 0);
ProfessionbuddyBot.Debug("Searching AH for {0}", ae.Name);
_queueTimer.Start();
}
else if (_queueTimer.ElapsedMilliseconds <= 10000)
{
using (StyxWoW.Memory.AcquireFrame())
{
if (
Lua.GetReturnVal <int>("if CanSendAuctionQuery('list') == 1 then return 1 else return 0 end ", 0) ==
1)
{
_queueTimer.Reset();
_totalAuctions = Lua.GetReturnVal <int>("return GetNumAuctionItems('list')", 1);
string lua = string.Format(SellItemOnAhAction.ScanAhFormatLua,
ae.LowestBo, ae.MyAuctions, ae.Id, IgnoreStackSizeBelow, int.MaxValue);
List <string> retVals = Lua.GetReturnValues(lua);
uint.TryParse(retVals[0], out ae.LowestBo);
uint.TryParse(retVals[1], out ae.MyAuctions);
if (++_page >= (int)Math.Ceiling((double)_totalAuctions / 50))
{
scanned = true;
}
}
}
}
else
{
scanned = true;
}
// reset to default values in preparations for next scan
if (scanned)
{
ProfessionbuddyBot.Debug("lowest buyout {0}", ae.LowestBo);
_queueTimer.Reset();
_totalAuctions = 0;
_page = 0;
}
return(scanned);
}
public override async Task <AdminGetAuctionResponse> GetAuction(AdminGetAuctionRequest request, ServerCallContext context)
{
if (!(await CheckPassword(context)))
{
throw new RpcException(new Status(StatusCode.PermissionDenied, "you are not authorized"));
}
Guid auctionId;
if (!Guid.TryParse(request.AuctionId, out auctionId))
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "entryid is not a guid"));
}
var auction = _auctionService.GetAuction(auctionId);
var res = new AdminGetAuctionResponse
{
Auction = new Auction
{
Id = auction.Id.ToString(),
StartedAt = auction.StartedAt,
Duration = auction.Duration,
FinishedAt = auction.FinishedAt,
}
};
foreach (var ae in auction.AuctionEntries)
{
var auctionEntry = new AuctionEntry
{
Amount = ae.Amount,
Id = ae.Id.ToString(),
Description = ae.Description,
Message = ae.Message,
PaymentRequest = ae.PaymentRequest
};
res.AuctionEntries.Add(auctionEntry);
}
return(res);
}
private bool SellOnAh(AuctionEntry ae)
{
if (!_posted)
{
int subAmount = AmountType == AmountBasedType.Amount ? Amount - (int)ae.MyAuctions : Amount;
int amount = AmountType == AmountBasedType.Everything
? (_leftOver == 0 ? int.MaxValue : _leftOver)
: (_leftOver == 0 ? subAmount : _leftOver);
string lua = string.Format(
SellOnAhLuaFormat,
ae.Id,
amount,
StackSize,
ae.Bid,
ae.Buyout,
(int)RunTime,
PostPartialStacks.ToString().ToLowerInvariant());
var ret = Lua.GetReturnVal <int>(lua, 0);
if (ret != -1) // returns -1 if waiting for auction to finish posting..
{
_leftOver = ret;
}
if (_leftOver == 0)
{
_posted = true;
}
}
//wait for auctions to finish listing before moving on
if (_posted)
{
bool ret = Lua.GetReturnVal <int>("if AuctionProgressFrame:IsVisible() == nil then return 1 else return 0 end ", 0) == 1;
if (ret) // we're done listing this item so reset to default values
{
_posted = false;
_leftOver = 0;
}
return(ret);
}
return(false);
}
public void Initialize(AuctionEntry auction, Item item)
{
AuctionItemID = (int)auction.Id;
Item = new ItemInstance(item);
BidAmount = auction.bid;
}
public MailSender(AuctionEntry sender)
{
m_messageType = MailMessageType.Auction;
m_senderId = sender.GetHouseId();
m_stationery = MailStationery.Auction;
}
public void DeleteEntry(AuctionEntry entry)
{
Database.DeleteAuctionRoom(entry.RandomId);
auctionEntries.Remove(entry);
}
public void AddExistingEntry(AuctionEntry entry)
{
auctionEntries.Add(entry);
}
public void AddEntry(AuctionEntry entry)
{
entry.auctionRoomPlacedIn = this;
Database.AddAuctionRoom(entry, this.RoomId);
auctionEntries.Add(entry);
}
/// <summary>
///
/// </summary>
/// <param name="floor"></param>
/// <param name="auction"></param>
public void Add(AuctionEntry auction)
{
var floor = GetFloorByQuantity(auction.Item.Quantity);
if (floor == AuctionCategoryFloorEnum.INVALID)
throw new InvalidOperationException("AuctionCategory::Add invalid floor for quantity=" + auction.Item.Quantity);
m_auctionsByFloor[floor].Add(auction);
m_auctionsByFloor[floor].Sort();
}
/// <summary>
///
/// </summary>
/// <param name="auction"></param>
public bool Remove(AuctionEntry auction)
{
return m_auctionsByFloor[GetFloorByQuantity(auction.Item.Quantity)].Remove(auction);
}
// Called when an auction expires.
public virtual void OnAuctionExpire(AuctionHouseObject ah, AuctionEntry entry)
{
}
// Called when an auction was succesfully completed.
public virtual void OnAuctionSuccessful(AuctionHouseObject ah, AuctionEntry entry)
{
}
/// <summary>
///
/// </summary>
/// <param name="entry"></param>
public void Add(AuctionEntry entry)
{
var templateId = entry.Item.TemplateId;
var itemType = entry.Item.Template.Type;
AuctionCategory category = null;
if (!m_categoriesByTemplate.ContainsKey(templateId))
m_categoriesByTemplate.Add(templateId, new List<AuctionCategory>());
category = m_categoriesByTemplate[templateId].Find(categ => categ.IsValidForThisCategory(entry.Item));
if (category == null)
{
category = new AuctionCategory(itemType, templateId, m_nextCategoryId++);
var type = entry.Item.Template.Type;
if (!m_templatesByType.ContainsKey(type))
m_templatesByType.Add(type, new List<int>());
if(!m_templatesByType[type].Contains(templateId))
m_templatesByType[type].Add(templateId);
m_categoriesByTemplate[templateId].Add(category);
m_categoryById.Add(category.Id, category);
category.Add(entry);
base.Dispatch(WorldMessage.AUCTION_HOUSE_CATEGORY_MOVEMENT(OperatorEnum.OPERATOR_ADD, category));
}
else
{
category.Add(entry);
}
if (!m_auctionsByAccount.ContainsKey(entry.OwnerId))
m_auctionsByAccount.Add(entry.OwnerId, new List<AuctionEntry>());
m_auctionsByAccount[entry.OwnerId].Add(entry);
UpdateMiddlePrice(category.TemplateId);
}
public void Initialize(AuctionEntry auction, Item item)
{
AuctionItemID = (int)auction.Id;
Item = new ItemInstance(item);
Bidder = ObjectGuid.Create(HighGuid.Player, auction.bidder);
}
protected async override Task Run()
{
if (Lua.GetReturnVal <int>("if AuctionFrame and AuctionFrame:IsVisible() then return 1 else return 0 end ", 0) == 0)
{
MoveToAh();
}
else
{
if (_toScanItemList == null)
{
_toScanItemList = BuildScanItemList();
_toSellItemList = new List <AuctionEntry>();
}
if (_toScanItemList.Count == 0 && _toSellItemList.Count == 0)
{
_toScanItemList = null;
IsDone = true;
return;
}
if (_toScanItemList.Count > 0)
{
AuctionEntry ae = _toScanItemList[0];
bool scanDone = ScanAh(ref ae);
_toScanItemList[0] = ae; // update
if (scanDone)
{
uint lowestBo = ae.LowestBo;
if (lowestBo > MaxBuyout.TotalCopper)
{
ae.Buyout = MaxBuyout.TotalCopper;
}
else if (lowestBo < MinBuyout.TotalCopper)
{
ae.Buyout = MinBuyout.TotalCopper;
}
else
{
ae.Buyout = lowestBo - (uint)Math.Ceiling((lowestBo * UndercutPrecent / 100d));
}
ae.Bid = (uint)(ae.Buyout * BidPrecent / 100d);
bool enoughItemsPosted = AmountType == AmountBasedType.Amount && ae.MyAuctions >= Amount;
bool tooLowBuyout = !PostIfBelowMinBuyout && lowestBo < MinBuyout.TotalCopper;
ProfessionbuddyBot.Debug("Post If Below MinBuyout:{0} ", PostIfBelowMinBuyout, MinBuyout.TotalCopper);
ProfessionbuddyBot.Debug(
"Lowest Buyout on AH: {0}, My Minimum Bouyout: {1}",
AuctionEntry.GoldString(lowestBo),
AuctionEntry.GoldString(MinBuyout.TotalCopper));
if (!enoughItemsPosted && !tooLowBuyout)
{
_toSellItemList.Add(ae);
}
else
{
PBLog.Log(
"Skipping {0} since {1}",
ae.Name,
tooLowBuyout
? string.Format("lowest buyout:{0} is below my MinBuyout:{1}", AuctionEntry.GoldString(lowestBo), MinBuyout)
: string.Format("{0} items from me are already posted. Max amount is {1}", ae.MyAuctions, Amount));
}
_toScanItemList.RemoveAt(0);
}
if (_toScanItemList.Count == 0)
{
ProfessionbuddyBot.Debug("Finished scanning for items");
}
}
if (_toSellItemList.Count > 0)
{
if (SellOnAh(_toSellItemList[0]))
{
PBLog.Log(
"Selling {0} for {1}. {2}",
_toSellItemList[0].Name,
AuctionEntry.GoldString(_toSellItemList[0].Buyout),
_toSellItemList[0].LowestBo == uint.MaxValue
? "There is no competition"
: string.Format("Competition is at {0}", AuctionEntry.GoldString(_toSellItemList[0].LowestBo)));
_toSellItemList.RemoveAt(0);
}
}
}
}
