SHARE
TWEET

com.l2jserver.gameserver.model.intemauct.ItemAuctionInstance

fforc9e Apr 28th, 2014 170 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * This program is free software: you can redistribute it and/or modify it under
  3.  * the terms of the GNU General Public License as published by the Free Software
  4.  * Foundation, either version 3 of the License, or (at your option) any later
  5.  * version.
  6.  *
  7.  * This program is distributed in the hope that it will be useful, but WITHOUT
  8.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  9.  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  10.  * details.
  11.  *
  12.  * You should have received a copy of the GNU General Public License along with
  13.  * this program. If not, see <http://www.gnu.org/licenses/>.
  14.  */
  15. package com.l2jserver.gameserver.model.itemauction;
  16.  
  17. import gnu.trove.TIntObjectHashMap;
  18.  
  19. import java.sql.Connection;
  20. import java.sql.PreparedStatement;
  21. import java.sql.ResultSet;
  22. import java.sql.SQLException;
  23. import java.text.SimpleDateFormat;
  24. import java.util.ArrayList;
  25. import java.util.Arrays;
  26. import java.util.Comparator;
  27. import java.util.Date;
  28. import java.util.concurrent.ScheduledFuture;
  29. import java.util.concurrent.TimeUnit;
  30. import java.util.concurrent.atomic.AtomicInteger;
  31. import java.util.logging.Level;
  32. import java.util.logging.Logger;
  33.  
  34. import org.w3c.dom.NamedNodeMap;
  35. import org.w3c.dom.Node;
  36.  
  37. import com.l2jserver.Config;
  38. import com.l2jserver.L2DatabaseFactory;
  39. import com.l2jserver.gameserver.ThreadPoolManager;
  40. import com.l2jserver.gameserver.datatables.CharNameTable;
  41. import com.l2jserver.gameserver.instancemanager.ItemAuctionManager;
  42. import com.l2jserver.gameserver.model.L2ItemInstance;
  43. import com.l2jserver.gameserver.model.L2ItemInstance.ItemLocation;
  44. import com.l2jserver.gameserver.model.L2World;
  45. import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  46. import com.l2jserver.gameserver.network.SystemMessageId;
  47. import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
  48. import com.l2jserver.gameserver.templates.StatsSet;
  49. import com.l2jserver.util.Rnd;
  50.  
  51. public final class ItemAuctionInstance
  52. {
  53.         static final Logger _log = Logger.getLogger(ItemAuctionInstance.class.getName());
  54.         private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("HH:mm:ss dd.MM.yy");
  55.        
  56.         private static final long START_TIME_SPACE = TimeUnit.MILLISECONDS.convert(1, TimeUnit.MINUTES);
  57.         private static final long FINISH_TIME_SPACE = TimeUnit.MILLISECONDS.convert(10, TimeUnit.MINUTES);
  58.        
  59.         private final int _instanceId;
  60.         private final AtomicInteger _auctionIds;
  61.         private final TIntObjectHashMap<ItemAuction> _auctions;
  62.         private final ArrayList<AuctionItem> _items;
  63.         private final AuctionDateGenerator _dateGenerator;
  64.        
  65.         private ItemAuction _currentAuction;
  66.         private ItemAuction _nextAuction;
  67.         private ScheduledFuture<?> _stateTask;
  68.        
  69.         public ItemAuctionInstance(final int instanceId, final AtomicInteger auctionIds, final Node node) throws Exception
  70.         {
  71.                 _instanceId = instanceId;
  72.                 _auctionIds = auctionIds;
  73.                 _auctions = new TIntObjectHashMap<ItemAuction>();
  74.                 _items = new ArrayList<AuctionItem>();
  75.                
  76.                 final NamedNodeMap nanode = node.getAttributes();
  77.                 final StatsSet generatorConfig = new StatsSet();
  78.                 for (int i = nanode.getLength(); i-- > 0;)
  79.                 {
  80.                         final Node n = nanode.item(i);
  81.                         if (n != null)
  82.                                 generatorConfig.set(n.getNodeName(), n.getNodeValue());
  83.                 }
  84.                
  85.                 _dateGenerator = new AuctionDateGenerator(generatorConfig);
  86.                
  87.                 for (Node na = node.getFirstChild(); na != null; na = na.getNextSibling())
  88.                 {
  89.                         try
  90.                         {
  91.                                 if ("item".equalsIgnoreCase(na.getNodeName()))
  92.                                 {
  93.                                         final NamedNodeMap naa = na.getAttributes();
  94.                                         final int auctionItemId = Integer.parseInt(naa.getNamedItem("auctionItemId").getNodeValue());
  95.                                         final int auctionLenght = Integer.parseInt(naa.getNamedItem("auctionLenght").getNodeValue());
  96.                                         final long auctionInitBid = Integer.parseInt(naa.getNamedItem("auctionInitBid").getNodeValue());
  97.                                        
  98.                                         final int itemId = Integer.parseInt(naa.getNamedItem("itemId").getNodeValue());
  99.                                         final int itemCount = Integer.parseInt(naa.getNamedItem("itemCount").getNodeValue());
  100.                                        
  101.                                         if (auctionLenght < 1)
  102.                                                 throw new IllegalArgumentException("auctionLenght < 1 for instanceId: " + _instanceId + ", itemId " + itemId);
  103.                                        
  104.                                         final StatsSet itemExtra = new StatsSet();
  105.                                         final AuctionItem item = new AuctionItem(auctionItemId, auctionLenght, auctionInitBid, itemId, itemCount, itemExtra);
  106.                                        
  107.                                         if (!item.checkItemExists())
  108.                                                 throw new IllegalArgumentException("Item with id " + itemId + " not found");
  109.                                        
  110.                                         for (final AuctionItem tmp : _items)
  111.                                         {
  112.                                                 if (tmp.getAuctionItemId() == auctionItemId)
  113.                                                         throw new IllegalArgumentException("Dublicated auction item id " + auctionItemId);
  114.                                         }
  115.                                        
  116.                                         _items.add(item);
  117.                                        
  118.                                         for (Node nb = na.getFirstChild(); nb != null; nb = nb.getNextSibling())
  119.                                         {
  120.                                                 if ("extra".equalsIgnoreCase(nb.getNodeName()))
  121.                                                 {
  122.                                                         final NamedNodeMap nab = nb.getAttributes();
  123.                                                         for (int i = nab.getLength(); i-- > 0;)
  124.                                                         {
  125.                                                                 final Node n = nab.item(i);
  126.                                                                 if (n != null)
  127.                                                                         itemExtra.set(n.getNodeName(), n.getNodeValue());
  128.                                                         }
  129.                                                 }
  130.                                         }
  131.                                 }
  132.                         }
  133.                         catch (final IllegalArgumentException e)
  134.                         {
  135.                                 _log.log(Level.WARNING, "ItemAuctionInstance: Failed loading auction item", e);
  136.                         }
  137.                 }
  138.                
  139.                 if (_items.isEmpty())
  140.                         throw new IllegalArgumentException("No items defined");
  141.                
  142.                 Connection con = null;
  143.                 try
  144.                 {
  145.                         con = L2DatabaseFactory.getInstance().getConnection();
  146.                         PreparedStatement statement = con.prepareStatement("SELECT auctionId FROM item_auction WHERE instanceId=?");
  147.                         statement.setInt(1, _instanceId);
  148.                         ResultSet rset = statement.executeQuery();
  149.                        
  150.                         while (rset.next())
  151.                         {
  152.                                 final int auctionId = rset.getInt(1);
  153.                                 try
  154.                                 {
  155.                                         final ItemAuction auction = loadAuction(auctionId);
  156.                                         if (auction != null)
  157.                                         {
  158.                                                 _auctions.put(auctionId, auction);
  159.                                         }
  160.                                         else
  161.                                         {
  162.                                                 ItemAuctionManager.deleteAuction(auctionId);
  163.                                         }
  164.                                 }
  165.                                 catch (final SQLException e)
  166.                                 {
  167.                                         _log.log(Level.WARNING, "ItemAuctionInstance: Failed loading auction: " + auctionId, e);
  168.                                 }
  169.                         }
  170.                 }
  171.                 catch (final SQLException e)
  172.                 {
  173.                         _log.log(Level.SEVERE, "L2ItemAuctionInstance: Failed loading auctions.", e);
  174.                         return;
  175.                 }
  176.                 finally
  177.                 {
  178.                         L2DatabaseFactory.close(con);
  179.                 }
  180.                
  181.                 _log.log(Level.INFO, "L2ItemAuctionInstance: Loaded " + _items.size() + " item(s) and registered " + _auctions.size() + " auction(s) for instance " + _instanceId + ".");
  182.                 checkAndSetCurrentAndNextAuction();
  183.         }
  184.        
  185.         public final ItemAuction getCurrentAuction()
  186.         {
  187.                 return _currentAuction;
  188.         }
  189.        
  190.         public final ItemAuction getNextAuction()
  191.         {
  192.                 return _nextAuction;
  193.         }
  194.        
  195.         public final void shutdown()
  196.         {
  197.                 final ScheduledFuture<?> stateTask = _stateTask;
  198.                 if (stateTask != null)
  199.                         stateTask.cancel(false);
  200.         }
  201.        
  202.         private final AuctionItem getAuctionItem(final int auctionItemId)
  203.         {
  204.                 for (int i = _items.size(); i-- > 0;)
  205.                 {
  206.                         final AuctionItem item = _items.get(i);
  207.                         if (item.getAuctionItemId() == auctionItemId)
  208.                                 return item;
  209.                 }
  210.                 return null;
  211.         }
  212.        
  213.         final void checkAndSetCurrentAndNextAuction()
  214.         {
  215.                 final ItemAuction[] auctions = _auctions.getValues(new ItemAuction[_auctions.size()]);
  216.                
  217.                 ItemAuction currentAuction = null;
  218.                 ItemAuction nextAuction = null;
  219.                
  220.                 switch (auctions.length)
  221.                 {
  222.                         case 0:
  223.                         {
  224.                                 nextAuction = createAuction(System.currentTimeMillis() + START_TIME_SPACE);
  225.                                 break;
  226.                         }
  227.                        
  228.                         case 1:
  229.                         {
  230.                                 switch (auctions[0].getAuctionState())
  231.                                 {
  232.                                         case CREATED:
  233.                                         {
  234.                                                 if (auctions[0].getStartingTime() < (System.currentTimeMillis() + START_TIME_SPACE))
  235.                                                 {
  236.                                                         currentAuction = auctions[0];
  237.                                                         nextAuction = createAuction(System.currentTimeMillis() + START_TIME_SPACE);
  238.                                                 }
  239.                                                 else
  240.                                                 {
  241.                                                         nextAuction = auctions[0];
  242.                                                 }
  243.                                                 break;
  244.                                         }
  245.                                        
  246.                                         case STARTED:
  247.                                         {
  248.                                                 currentAuction = auctions[0];
  249.                                                 nextAuction = createAuction(Math.max(currentAuction.getEndingTime() + FINISH_TIME_SPACE, System.currentTimeMillis() + START_TIME_SPACE));
  250.                                                 break;
  251.                                         }
  252.                                        
  253.                                         case FINISHED:
  254.                                         {
  255.                                                 currentAuction = auctions[0];
  256.                                                 nextAuction = createAuction(System.currentTimeMillis() + START_TIME_SPACE);
  257.                                                 break;
  258.                                         }
  259.                                        
  260.                                         default:
  261.                                                 throw new IllegalArgumentException();
  262.                                 }
  263.                                 break;
  264.                         }
  265.                        
  266.                         default:
  267.                         {
  268.                                 Arrays.sort(auctions, new Comparator<ItemAuction>() {
  269.                                         @Override
  270.                                         //TODO REMOVE override maybe
  271.                                         public final int compare(final ItemAuction o1, final ItemAuction o2)
  272.                                         {
  273.                                                 return ((Long) o2.getStartingTime()).compareTo(o1.getStartingTime());
  274.                                         }
  275.                                 });
  276.                                
  277.                                 // just to make sure we won`t skip any auction because of little different times
  278.                                 final long currentTime = System.currentTimeMillis();
  279.                                
  280.                                 for (int i = 0; i < auctions.length; i++)
  281.                                 {
  282.                                         final ItemAuction auction = auctions[i];
  283.                                         if (auction.getAuctionState() == ItemAuctionState.STARTED)
  284.                                         {
  285.                                                 currentAuction = auction;
  286.                                                 break;
  287.                                         }
  288.                                         else if (auction.getStartingTime() <= currentTime)
  289.                                         {
  290.                                                 currentAuction = auction;
  291.                                                 break; // only first
  292.                                         }
  293.                                 }
  294.                                
  295.                                 for (int i = 0; i < auctions.length; i++)
  296.                                 {
  297.                                         final ItemAuction auction = auctions[i];
  298.                                         if (auction.getStartingTime() > currentTime && currentAuction != auction)
  299.                                         {
  300.                                                 nextAuction = auction;
  301.                                                 break;
  302.                                         }
  303.                                 }
  304.                                
  305.                                 if (nextAuction == null)
  306.                                         nextAuction = createAuction(System.currentTimeMillis() + START_TIME_SPACE);
  307.                                 break;
  308.                         }
  309.                 }
  310.                
  311.                 _auctions.put(nextAuction.getAuctionId(), nextAuction);
  312.                
  313.                 _currentAuction = currentAuction;
  314.                 _nextAuction = nextAuction;
  315.                
  316.                 if (currentAuction != null && currentAuction.getAuctionState() != ItemAuctionState.FINISHED)
  317.                 {
  318.                         if (currentAuction.getAuctionState() == ItemAuctionState.STARTED)
  319.                                 setStateTask(ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleAuctionTask(currentAuction), Math.max(currentAuction.getEndingTime() - System.currentTimeMillis(), 0L)));
  320.                         else
  321.                                 setStateTask(ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleAuctionTask(currentAuction), Math.max(currentAuction.getStartingTime() - System.currentTimeMillis(), 0L)));
  322.                         _log.log(Level.INFO, "L2ItemAuctionInstance: Schedule current auction " + currentAuction.getAuctionId() + " for instance " + _instanceId);
  323.                 }
  324.                 else
  325.                 {
  326.                         setStateTask(ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleAuctionTask(nextAuction), Math.max(nextAuction.getStartingTime() - System.currentTimeMillis(), 0L)));
  327.                         _log.log(Level.INFO, "L2ItemAuctionInstance: Schedule next auction " + nextAuction.getAuctionId() + " on " + DATE_FORMAT.format(new Date(nextAuction.getStartingTime())) + " for instance " + _instanceId);
  328.                 }
  329.         }
  330.        
  331.         public final ItemAuction getAuction(final int auctionId)
  332.         {
  333.                 return _auctions.get(auctionId);
  334.         }
  335.        
  336.         public final ItemAuction[] getAuctionsByBidder(final int bidderObjId)
  337.         {
  338.                 final ItemAuction[] auctions = getAuctions();
  339.                 final ArrayList<ItemAuction> stack = new ArrayList<ItemAuction>(auctions.length);
  340.                 for (final ItemAuction auction : getAuctions())
  341.                 {
  342.                         if (auction.getAuctionState() != ItemAuctionState.CREATED)
  343.                         {
  344.                                 final ItemAuctionBid bid = auction.getBidFor(bidderObjId);
  345.                                 if (bid != null)
  346.                                         stack.add(auction);
  347.                         }
  348.                 }
  349.                 return stack.toArray(new ItemAuction[stack.size()]);
  350.         }
  351.        
  352.         public final ItemAuction[] getAuctions()
  353.         {
  354.                 final ItemAuction[] auctions;
  355.                
  356.                 synchronized (_auctions)
  357.                 {
  358.                         auctions = _auctions.getValues(new ItemAuction[_auctions.size()]);
  359.                 }
  360.                
  361.                 return auctions;
  362.         }
  363.        
  364.         private final class ScheduleAuctionTask implements Runnable
  365.         {
  366.                 private final ItemAuction _auction;
  367.                
  368.                 public ScheduleAuctionTask(final ItemAuction auction)
  369.                 {
  370.                         _auction = auction;
  371.                 }
  372.                
  373.                 @Override
  374.                 public final void run()
  375.                 {
  376.                         try
  377.                         {
  378.                                 runImpl();
  379.                         }
  380.                         catch (final Exception e)
  381.                         {
  382.                                 _log.log(Level.SEVERE, "L2ItemAuctionInstance: Failed scheduling auction " + _auction.getAuctionId(), e);
  383.                         }
  384.                 }
  385.                
  386.                 private final void runImpl() throws Exception
  387.                 {
  388.                         final ItemAuctionState state = _auction.getAuctionState();
  389.                         switch (state)
  390.                         {
  391.                                 case CREATED:
  392.                                 {
  393.                                         if (!_auction.setAuctionState(state, ItemAuctionState.STARTED))
  394.                                                 throw new IllegalStateException("Could not set auction state: " + ItemAuctionState.STARTED.toString() + ", expected: " + state.toString());
  395.                                        
  396.                                         _log.log(Level.INFO, "L2ItemAuctionInstance: Auction " + _auction.getAuctionId() + " has started for instance " + _auction.getInstanceId());
  397.                                         checkAndSetCurrentAndNextAuction();
  398.                                         break;
  399.                                 }
  400.                                
  401.                                 case STARTED:
  402.                                 {
  403.                                         switch (_auction.getAuctionEndingExtendState())
  404.                                         {
  405.                                                 case EXTEND_BY_5_MIN:
  406.                                                 {
  407.                                                         if (_auction.getScheduledAuctionEndingExtendState() == ItemAuctionExtendState.INITIAL)
  408.                                                         {
  409.                                                                 _auction.setScheduledAuctionEndingExtendState(ItemAuctionExtendState.EXTEND_BY_5_MIN);
  410.                                                                 setStateTask(ThreadPoolManager.getInstance().scheduleGeneral(this, Math.max(_auction.getEndingTime() - System.currentTimeMillis(), 0L)));
  411.                                                                 return;
  412.                                                         }
  413.                                                         break;
  414.                                                 }
  415.                                                
  416.                                                 case EXTEND_BY_3_MIN:
  417.                                                 {
  418.                                                         if (_auction.getScheduledAuctionEndingExtendState() != ItemAuctionExtendState.EXTEND_BY_3_MIN)
  419.                                                         {
  420.                                                                 _auction.setScheduledAuctionEndingExtendState(ItemAuctionExtendState.EXTEND_BY_3_MIN);
  421.                                                                 setStateTask(ThreadPoolManager.getInstance().scheduleGeneral(this, Math.max(_auction.getEndingTime() - System.currentTimeMillis(), 0L)));
  422.                                                                 return;
  423.                                                         }
  424.                                                         break;
  425.                                                 }
  426.                                                
  427.                                                 case EXTEND_BY_CONFIG_PHASE_A:
  428.                                                 {
  429.                                                         if (_auction.getScheduledAuctionEndingExtendState() != ItemAuctionExtendState.EXTEND_BY_CONFIG_PHASE_B)
  430.                                                         {
  431.                                                                 _auction.setScheduledAuctionEndingExtendState(ItemAuctionExtendState.EXTEND_BY_CONFIG_PHASE_B);
  432.                                                                 setStateTask(ThreadPoolManager.getInstance().scheduleGeneral(this, Math.max(_auction.getEndingTime() - System.currentTimeMillis(), 0L)));
  433.                                                                 return;
  434.                                                         }
  435.                                                         break;
  436.                                                 }
  437.                                                
  438.                                                 case EXTEND_BY_CONFIG_PHASE_B:
  439.                                                 {
  440.                                                         if (_auction.getScheduledAuctionEndingExtendState() != ItemAuctionExtendState.EXTEND_BY_CONFIG_PHASE_A)
  441.                                                         {
  442.                                                                 _auction.setScheduledAuctionEndingExtendState(ItemAuctionExtendState.EXTEND_BY_CONFIG_PHASE_A);
  443.                                                                 setStateTask(ThreadPoolManager.getInstance().scheduleGeneral(this, Math.max(_auction.getEndingTime() - System.currentTimeMillis(), 0L)));
  444.                                                                 return;
  445.                                                         }
  446.                                                 }
  447.                                         }
  448.                                        
  449.                                         if (!_auction.setAuctionState(state, ItemAuctionState.FINISHED))
  450.                                                 throw new IllegalStateException("Could not set auction state: " + ItemAuctionState.FINISHED.toString() + ", expected: " + state.toString());
  451.                                        
  452.                                         onAuctionFinished(_auction);
  453.                                         checkAndSetCurrentAndNextAuction();
  454.                                         break;
  455.                                 }
  456.                                
  457.                                 default:
  458.                                         throw new IllegalStateException("Invalid state: " + state);
  459.                         }
  460.                 }
  461.         }
  462.        
  463.         final void onAuctionFinished(final ItemAuction auction)
  464.         {
  465.                 auction.broadcastToAllBiddersInternal(new SystemMessage(SystemMessageId.S1_AUCTION_ENDED).addNumber(auction.getAuctionId()));
  466.                
  467.                 final ItemAuctionBid bid = auction.getHighestBid();
  468.                 if (bid != null)
  469.                 {
  470.                         final L2ItemInstance item = auction.createNewItemInstance();
  471.                         final L2PcInstance player = bid.getPlayer();
  472.                         if (player != null)
  473.                         {
  474.                                 player.getWarehouse().addItem("ItemAuction", item, null, null);
  475.                                 player.sendPacket(new SystemMessage(SystemMessageId.WON_BID_ITEM_CAN_BE_FOUND_IN_WAREHOUSE));
  476.                                
  477.                                 _log.log(Level.INFO, "L2ItemAuctionInstance: Auction " + auction.getAuctionId() + " has finished. Highest bid by " + player.getName() + " for instance " + _instanceId);
  478.                         }
  479.                         else
  480.                         {
  481.                                 item.setOwnerId(bid.getPlayerObjId());
  482.                                 item.setLocation(ItemLocation.WAREHOUSE);
  483.                                 item.updateDatabase();
  484.                                 L2World.getInstance().removeObject(item);
  485.                                
  486.                                 _log.log(Level.INFO, "L2ItemAuctionInstance: Auction " + auction.getAuctionId() + " has finished. Highest bid by " + CharNameTable.getInstance().getNameById(bid.getPlayerObjId()) + " for instance " + _instanceId);
  487.                         }
  488.                        
  489.                         // Clean all canceled bids
  490.                         auction.clearCanceledBids();
  491.                 }
  492.                 else
  493.                 {
  494.                         _log.log(Level.INFO, "L2ItemAuctionInstance: Auction " + auction.getAuctionId() + " has finished. There have not been any bid for instance " + _instanceId);
  495.                 }
  496.         }
  497.        
  498.         final void setStateTask(final ScheduledFuture<?> future)
  499.         {
  500.                 final ScheduledFuture<?> stateTask = _stateTask;
  501.                 if (stateTask != null)
  502.                         stateTask.cancel(false);
  503.                
  504.                 _stateTask = future;
  505.         }
  506.        
  507.         private final ItemAuction createAuction(final long after)
  508.         {
  509.                 final AuctionItem auctionItem = _items.get(Rnd.get(_items.size()));
  510.                 final long startingTime = _dateGenerator.nextDate(after);
  511.                 final long endingTime = startingTime + TimeUnit.MILLISECONDS.convert(auctionItem.getAuctionLength(), TimeUnit.MINUTES);
  512.                 final ItemAuction auction = new ItemAuction(_auctionIds.getAndIncrement(), _instanceId, startingTime, endingTime, auctionItem);
  513.                 auction.storeMe();
  514.                 return auction;
  515.         }
  516.        
  517.         private final ItemAuction loadAuction(final int auctionId) throws SQLException
  518.         {
  519.                 Connection con = null;
  520.                 try
  521.                 {
  522.                         con = L2DatabaseFactory.getInstance().getConnection();
  523.                         PreparedStatement statement = con.prepareStatement("SELECT auctionItemId,startingTime,endingTime,auctionStateId FROM item_auction WHERE auctionId=?");
  524.                         statement.setInt(1, auctionId);
  525.                         ResultSet rset = statement.executeQuery();
  526.                        
  527.                         if (!rset.next())
  528.                         {
  529.                                 _log.log(Level.WARNING, "ItemAuctionInstance: Auction data not found for auction: " + auctionId);
  530.                                 return null;
  531.                         }
  532.                        
  533.                         final int auctionItemId = rset.getInt(1);
  534.                         final long startingTime = rset.getLong(2);
  535.                         final long endingTime = rset.getLong(3);
  536.                         final byte auctionStateId = rset.getByte(4);
  537.                         statement.close();
  538.                        
  539.                         if (startingTime >= endingTime)
  540.                         {
  541.                                 _log.log(Level.WARNING, "ItemAuctionInstance: Invalid starting/ending paramaters for auction: " + auctionId);
  542.                                 return null;
  543.                         }
  544.                        
  545.                         final AuctionItem auctionItem = getAuctionItem(auctionItemId);
  546.                         if (auctionItem == null)
  547.                         {
  548.                                 _log.log(Level.WARNING, "ItemAuctionInstance: AuctionItem: " + auctionItemId + ", not found for auction: " + auctionId);
  549.                                 return null;
  550.                         }
  551.                        
  552.                         final ItemAuctionState auctionState = ItemAuctionState.stateForStateId(auctionStateId);
  553.                         if (auctionState == null)
  554.                         {
  555.                                 _log.log(Level.WARNING, "ItemAuctionInstance: Invalid auctionStateId: " + auctionStateId + ", for auction: " + auctionId);
  556.                                 return null;
  557.                         }
  558.                        
  559.                         if (auctionState == ItemAuctionState.FINISHED
  560.                                         && startingTime < System.currentTimeMillis() - TimeUnit.MILLISECONDS.convert(Config.ALT_ITEM_AUCTION_EXPIRED_AFTER, TimeUnit.DAYS))
  561.                         {
  562.                                 _log.log(Level.INFO, "ItemAuctionInstance: Clearing expired auction: " + auctionId);
  563.                                 statement = con.prepareStatement("DELETE FROM item_auction WHERE auctionId=?");
  564.                                 statement.setInt(1, auctionId);
  565.                                 statement.execute();
  566.                                 statement.close();
  567.                                
  568.                                 statement = con.prepareStatement("DELETE FROM item_auction_bid WHERE auctionId=?");
  569.                                 statement.setInt(1, auctionId);
  570.                                 statement.execute();
  571.                                 statement.close();
  572.                                 return null;
  573.                         }
  574.                        
  575.                         statement = con.prepareStatement("SELECT playerObjId,playerBid FROM item_auction_bid WHERE auctionId=?");
  576.                         statement.setInt(1, auctionId);
  577.                         rset = statement.executeQuery();
  578.                        
  579.                         final ArrayList<ItemAuctionBid> auctionBids = new ArrayList<ItemAuctionBid>();
  580.                        
  581.                         while (rset.next())
  582.                         {
  583.                                 final int playerObjId = rset.getInt(1);
  584.                                 final long playerBid = rset.getLong(2);
  585.                                 final ItemAuctionBid bid = new ItemAuctionBid(playerObjId, playerBid);
  586.                                 auctionBids.add(bid);
  587.                         }
  588.                        
  589.                         return new ItemAuction(auctionId, _instanceId, startingTime, endingTime, auctionItem, auctionBids, auctionState);
  590.                 }
  591.                 finally
  592.                 {
  593.                         L2DatabaseFactory.close(con);
  594.                 }
  595.         }
  596. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top