
    public void openDuey() {
        c.getPlayer().setConversation(2);
        c.getSession().write(MaplePacketCreator.sendDuey((byte) 9, null, null));
    }

############################################################

    /*
    送货员相关内容
    */
    public static byte[] sendDuey(byte operation, List<MapleDueyActions> packages, List<MapleDueyActions> expired) {
        MaplePacketLittleEndianWriter mplew = new MaplePacketLittleEndianWriter();

        mplew.writeShort(SendPacketOpcode.DUEY.getValue());
        mplew.write(operation);
        if (packages == null) {
            mplew.write(0);
            mplew.write(0);
            mplew.write(0);
            return mplew.getPacket();
        }
        switch (operation) {
            case 9: { // Request 13 Digit AS
                mplew.write(1);
                // 0xFF = error
                break;
            }
            case 10: { // Open duey
                mplew.write(0); // != 0
                mplew.write(packages.size());
                for (MapleDueyActions dp : packages) {
                    mplew.writeInt(dp.getPackageId());
                    mplew.writeAsciiString(dp.getSender(), 13);
                    mplew.writeInt(dp.getMesos());
                    mplew.writeLong(PacketHelper.getTime(dp.getExpireTime()));
                    mplew.writeInt(dp.isQuick() ? 1 : 0);
                    mplew.writeAsciiString(dp.getContent(), 100);
                    mplew.writeZeroBytes(100);
                    mplew.write(0);
                    if (dp.getItem() != null) {
                        mplew.write(1);
                        PacketHelper.addItemInfo(mplew, dp.getItem());
                    } else {
                        mplew.write(0);
                    }
                }
                if (expired == null) {
                    mplew.write(0);
                    return mplew.getPacket();
                }
                mplew.write(expired.size());
                for (MapleDueyActions dp : expired) {
                    mplew.writeInt(dp.getPackageId());
                    mplew.writeAsciiString(dp.getSender(), 13);
                    mplew.writeLong(dp.getMesos());
                    if (dp.canReceive()) {
                        mplew.writeLong(PacketHelper.getTime(dp.getExpireTime()));
                    } else {
                        mplew.writeLong(0);
                    }
                    mplew.writeInt(dp.isQuick() ? 1 : 0);
                    mplew.writeAsciiString(dp.getContent(), 100);
                    mplew.writeZeroBytes(100);
                    mplew.write(0);
                    if (dp.getItem() != null) {
                        mplew.write(1);
                        PacketHelper.addItemInfo(mplew, dp.getItem());
                    } else {
                        mplew.write(0);
                    }
                }
                break;
            }
        }
        return mplew.getPacket();
    }

    /*
    送货员相关内容
    */
    public static byte[] removeItemFromDuey(boolean remove, int Package) {

        MaplePacketLittleEndianWriter mplew = new MaplePacketLittleEndianWriter();

        mplew.writeShort(SendPacketOpcode.DUEY.getValue());
        mplew.write(24);
        mplew.writeInt(Package);
        mplew.write(remove ? 3 : 4);

        return mplew.getPacket();
    }

    /*
    送货员相关内容
    */
    public static byte[] checkFailedDuey() {
        MaplePacketLittleEndianWriter mplew = new MaplePacketLittleEndianWriter();

        mplew.writeShort(SendPacketOpcode.DUEY.getValue());
        mplew.write(9);
        mplew.write(-1); // 0xFF = error
        return mplew.getPacket();
    }

    /*
    送货员相关内容
    */
    public static byte[] receiveParcel(String from, boolean quick) {
        MaplePacketLittleEndianWriter mplew = new MaplePacketLittleEndianWriter();
        mplew.writeShort(SendPacketOpcode.DUEY.getValue());
        mplew.write(0x1A);
        mplew.writeMapleAsciiString(from);
        mplew.write(quick ? 1 : 0);
        return mplew.getPacket();
    }
############################################################

package handling.channel.handler;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.List;
import client.inventory.Item;
import client.inventory.ItemFlag;
import constants.GameConstants;
import client.inventory.ItemLoader;
import client.MapleCharacter;
import client.MapleCharacterUtil;
import client.MapleClient;
import client.inventory.MapleInventoryType;
import database.DatabaseConnection;
import handling.channel.ChannelServer;
import handling.world.World;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import server.AutobanManager;
import tools.data.LittleEndianAccessor;
import server.MapleDueyActions;
import server.MapleInventoryManipulator;
import server.MapleItemInformationProvider;
import tools.MaplePacketCreator;
import tools.Pair;


public class DueyHandler {

    /*
     * 19 = Successful
     * 18 = One-of-a-kind Item is already in Reciever's delivery
     * 17 = The Character is unable to recieve the parcel
     * 15 = Same account
     * 14 = Name does not exist
     */
    public static final void DueyOperation(final LittleEndianAccessor slea, final MapleClient c) {

        final byte operation = slea.readByte();
        switch (operation) {
            case 0: {
                c.getPlayer().setConversation(2);
                c.getSession().write(MaplePacketCreator.sendDuey((byte) 9, null, null));
                break;
            }
            case 1: { // Start Duey, 13 digit AS
                //final String AS13Digit = slea.readMapleAsciiString();
                //		int unk = slea.readInt(); // Theres an int here, value = 1
                //  9 = error
                slea.skip(4);
                final int conv = c.getPlayer().getConversation();
                if (conv == 2) { // Duey
                    List<MapleDueyActions> list1 = new ArrayList<MapleDueyActions>();
                    List<MapleDueyActions> list2 = new ArrayList<MapleDueyActions>();
                    for (MapleDueyActions dp : loadItems((c.getPlayer()))) {
                        if (dp.isExpire()) {
                            list2.add(dp);
                        } else {
                            list1.add(dp);
                        }
                    }
                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 10, list1, list2));
                    for (MapleDueyActions dp : list2) {
                        removeItemFromDB(dp.getPackageId(), c.getPlayer().getId());
                    }
                }
                //  } else {
                //      c.getSession().write(MaplePacketCreator.checkFailedDuey());
                //  }
                break;
            }
            case 3: { // Send Item
                if (c.getPlayer().getConversation() != 2) {
                    return;
                }
                final byte inventId = slea.readByte();
                final short itemPos = slea.readShort();
                short amount = slea.readShort();
                if (amount < 0) {
                   return;
                }
                final int mesos = slea.readInt();
                final String recipient = slea.readMapleAsciiString();
                boolean quickdelivery = slea.readByte() > 0;
                String letter = "";
                int qq = 0;
                if (quickdelivery) {
                    if (!c.getPlayer().haveItem(5330000, 1) && !c.getPlayer().haveItem(5330001, 1)) {
                        return;
                    }
                    letter = slea.readMapleAsciiString();
                    qq = slea.readInt();
                }

                if (inventId > 0 && (amount <= 0 || amount > 9999)) {
                    c.getSession().close();
                    return;
                }

                final int finalcost = mesos + GameConstants.getTaxAmount(mesos) + (quickdelivery ? 0 : 5000);

                if (mesos >= 0 && mesos <= 100000000 && c.getPlayer().getMeso() >= finalcost) {
                    final int accid = MapleCharacterUtil.getAccByName(recipient);
                    final int cid = MapleCharacterUtil.getIdByName(recipient);
                    if (accid != -1) {
                        if (accid != c.getAccID()) {

                            boolean recipientOn = false;
                            MapleClient rClient = null;
                            int channel = World.Find.findChannel(recipient);
                            if (channel > -1) {
                                recipientOn = true;
                                ChannelServer rcserv = ChannelServer.getInstance(channel);
                                rClient = rcserv.getPlayerStorage().getCharacterByName(recipient).getClient();
                            }

                            if (inventId > 0) {
                                final MapleInventoryType inv = MapleInventoryType.getByType(inventId);
                                final Item item = c.getPlayer().getInventory(inv).getItem((byte) itemPos);
                                if (item == null) {
                                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 17, null, null)); // Unsuccessfull
                                    return;
                                }
                                List<MapleDueyActions> dps = loadItems(c.getPlayer());
                                for (MapleDueyActions mda : dps) {
                                    if (mda.getItem() != null) {
                                        MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
                                        if (ii.isPickupRestricted(mda.getItem().getItemId()) && mda.getItem().getItemId() == item.getItemId()) {
                                            c.getSession().write(MaplePacketCreator.sendDuey((byte) 18, null, null));
                                            return;
                                        }
                                    }
                                }
                                final short flag = item.getFlag();
                                if (ItemFlag.UNTRADEABLE.check(flag) || ItemFlag.LOCK.check(flag)) {
                                    c.getSession().write(MaplePacketCreator.enableActions());
                                    return;
                                }
                                if (GameConstants.isThrowingStar(item.getItemId()) || GameConstants.isBullet(item.getItemId())) {
                                    if (item.getQuantity() == 0) {
                                        amount = 0;
                                    }
                                }
                                if (c.getPlayer().getItemQuantity(item.getItemId(), false) >= amount) {
                                    final MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
                                    if (!ii.isDropRestricted(item.getItemId()) && !ii.isAccountShared(item.getItemId())) {
                                        Item toSend = item.copy();
                                        if (!GameConstants.isThrowingStar(toSend.getItemId()) && !GameConstants.isBullet(toSend.getItemId())) {
                                            toSend.setQuantity(amount);
                                        }
                                        if (addItemToDB(toSend, mesos, c.getPlayer().getName(), cid, recipientOn, letter, qq, quickdelivery)) {
                                            if (GameConstants.isThrowingStar(toSend.getItemId()) || GameConstants.isBullet(toSend.getItemId())) {
                                                MapleInventoryManipulator.removeFromSlot(c, inv, (byte) itemPos, toSend.getQuantity(), true, false);
                                            } else {
                                                MapleInventoryManipulator.removeFromSlot(c, inv, (byte) itemPos, amount, true, false);
                                            }
                                            if (quickdelivery) {
                                                if (c.getPlayer().haveItem(5330001, 1)) {
                                                    MapleInventoryManipulator.removeById(c, MapleInventoryType.CASH, 5330001, 1, false, false);
                                                } else if (c.getPlayer().haveItem(5330000, 1)) {
                                                    MapleInventoryManipulator.removeById(c, MapleInventoryType.CASH, 5330000, 1, false, false);
                                                }
                                            }

                                            c.getPlayer().gainMeso(-finalcost, false);
                                            c.getSession().write(MaplePacketCreator.sendDuey((byte) 19, null, null)); // Successfull
                                        } else {
                                            c.getSession().write(MaplePacketCreator.sendDuey((byte) 17, null, null)); // Unsuccessful
                                        }
                                    } else {
                                        c.getSession().write(MaplePacketCreator.sendDuey((byte) 17, null, null)); // Unsuccessfull
                                    }
                                } else {
                                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 17, null, null)); // Unsuccessfull
                                }
                            } else {
                                if (addMesoToDB(mesos, c.getPlayer().getName(), cid, recipientOn, letter, quickdelivery)) {
                                    c.getPlayer().gainMeso(-finalcost, false);

                                    if (quickdelivery) {
                                        if (c.getPlayer().haveItem(5330001, 1)) {
                                            MapleInventoryManipulator.removeById(c, MapleInventoryType.CASH, 5330001, 1, false, false);
                                        } else if (c.getPlayer().haveItem(5330000, 1)) {
                                            MapleInventoryManipulator.removeById(c, MapleInventoryType.CASH, 5330000, 1, false, false);
                                        }
                                    }
                                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 19, null, null));
                                } else {
                                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 17, null, null)); // Unsuccessfull
                                }
                            }
                            if (recipientOn && rClient != null) {
                                if (quickdelivery) {
                                    rClient.getSession().write(MaplePacketCreator.receiveParcel(c.getPlayer().getName(), quickdelivery));
                                }
                            }
                        } else {
                            c.getSession().write(MaplePacketCreator.sendDuey((byte) 15, null, null));
                        }
                    } else {
                        c.getSession().write(MaplePacketCreator.sendDuey((byte) 14, null, null));
                    }
                } else {
                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 12, null, null));
                }
                break;
            }
            case 5: { // Recieve Package
                if (c.getPlayer().getConversation() != 2) {
                    return;
                }
                final int packageid = slea.readInt();
                //System.out.println("Item attempted : " + packageid);
                final MapleDueyActions dp = loadSingleItem(packageid, c.getPlayer().getId());
                if (dp == null) {
                    return;
                }
                if (dp.isExpire() || !dp.canReceive()) { //packet edit;
                    return;
                }
                if (dp.getItem() != null && !MapleInventoryManipulator.checkSpace(c, dp.getItem().getItemId(), dp.getItem().getQuantity(), dp.getItem().getOwner())) {
                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 16, null, null));
                    return;
                } else if (dp.getMesos() < 0 || (dp.getMesos() + c.getPlayer().getMeso()) < 0) {
                    c.getSession().write(MaplePacketCreator.sendDuey((byte) 17, null, null));
                    return;
                }
                if (dp.getItem() != null) {
                    if (c.getPlayer().haveItem(dp.getItem().getItemId(), 1, true, true) && MapleItemInformationProvider.getInstance().isPickupRestricted(dp.getItem().getItemId())) {
                        c.getSession().write(MaplePacketCreator.sendDuey((byte) 18, null, null));
                        return;
                    }
                }
                removeItemFromDB(packageid, c.getPlayer().getId()); // Remove first
                //System.out.println("Item removed : " + packageid);
                if (dp.getItem() != null) {
                    MapleInventoryManipulator.addFromDrop(c, dp.getItem(), false);
                }
                if (dp.getMesos() != 0) {
                    c.getPlayer().gainMeso(dp.getMesos(), false);
                }
                c.getSession().write(MaplePacketCreator.removeItemFromDuey(false, packageid));
                break;
            }
            case 6: { // Remove package
                if (c.getPlayer().getConversation() != 2) {
                    return;
                }
                final int packageid = slea.readInt();
                removeItemFromDB(packageid, c.getPlayer().getId());
                c.getSession().write(MaplePacketCreator.removeItemFromDuey(true, packageid));
                break;
            }
            case 7:
            case 8: { // Close Duey
                c.getPlayer().setConversation(0);
                break;
            }

            default: {
                System.out.println("Unhandled Duey operation : " + operation);
                break;
            }
        }
    }

    public static boolean addNewItemToDb(int itemid, int quantity, int to, String from, String content, boolean ison) {
        Item item = null;
        if (quantity < 0 || quantity > 9999) {          
            return false;
        }
        if (itemid / 1000000 == 1) {
            item = MapleItemInformationProvider.getInstance().getEquipById(itemid);
        } else {
            item = new Item(itemid, (byte) 0, (short) quantity);
        }

        return addItemToDB(item, 0, from, to, ison, content, 1, true);
    }    

    private static final boolean addMesoToDB(final int mesos, final String sName, final int recipientID, final boolean isOn, String content, boolean quick) {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("INSERT INTO dueypackages (RecieverId, SenderName, Mesos, TimeStamp, Checked, Type, `Quick`, content) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
            ps.setInt(1, recipientID);
            ps.setString(2, sName);
            ps.setInt(3, mesos);
            ps.setLong(4, System.currentTimeMillis());
            ps.setInt(5, isOn ? 0 : 1);
            ps.setInt(6, 3);
            ps.setInt(7, quick ? 1 : 0);
            ps.setString(8, content);

            ps.executeUpdate();
            ps.close();

            return true;
        } catch (SQLException se) {
            se.printStackTrace();
            return false;
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
        }
    }

    public static final boolean addItemToDB(final Item item, final int mesos, final String sName, final int recipientID, final boolean isOn, String content, int qq, boolean Quick) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("INSERT INTO dueypackages (RecieverId, SenderName, Mesos, TimeStamp, Checked, Type, content, `Quick`) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", DatabaseConnection.RETURN_GENERATED_KEYS);
            ps.setInt(1, recipientID);
            ps.setString(2, sName);
            ps.setInt(3, mesos);
            ps.setLong(4, System.currentTimeMillis());
            ps.setInt(5, isOn ? 0 : 1);

            ps.setInt(6, item.getType());
            ps.setString(7, content);
            ps.setInt(8, Quick ? 1 : 0);
            ps.executeUpdate();

            rs = ps.getGeneratedKeys();
            if (rs.next()) {
                ItemLoader.送货道具.saveItems(Collections.singletonList(new Pair<Item, MapleInventoryType>(item, GameConstants.getInventoryType(item.getItemId()))), rs.getInt(1));
            }
            rs.close();
            ps.close();

            return true;
        } catch (SQLException se) {
            se.printStackTrace();
            return false;
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (rs != null) {
                try {
                    rs.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
        }
    }

    public static final void checkReceivePackage(MapleCharacter chr) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("SELECT packageid, `Quick`, `TimeStamp`, `SenderName` FROM dueypackages WHERE RecieverId = ? AND Checked = 1 LIMIT 1");
            ps.setInt(1, chr.getId());
            rs = ps.executeQuery();
            boolean b = rs.next();
            if (b) {
                boolean quick = rs.getInt("Quick") == 1;
                long timestamp = rs.getLong("TimeStamp");
                String s = rs.getString("SenderName");
                if (rs.next() && !rs.getString("SenderName").startsWith("[") && !rs.getString("SenderName").endsWith("]")) {
                    chr.getClient().getSession().write(MaplePacketCreator.sendDuey((byte) 28, null, null));
                    reciveMsg(chr.getClient(), chr.getId());
                } else if (b) {
                    if (quick) {
                        chr.getClient().getSession().write(MaplePacketCreator.receiveParcel(s, true));
                        reciveMsg(chr.getClient(), chr.getId());
                    } else if (timestamp + 12 * 3600000L < System.currentTimeMillis()) {
                        chr.getClient().getSession().write(MaplePacketCreator.receiveParcel(s, false));
                        reciveMsg(chr.getClient(), chr.getId());
                    }
                }
            }
        } catch (SQLException se) {
            se.printStackTrace();
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
            if (rs != null) {
                try {
                    rs.close();
                } catch (Exception e) {
                }
            }
        }
    }    

    public static final List<MapleDueyActions> loadItems(final MapleCharacter chr) {
        List<MapleDueyActions> packages = new LinkedList<MapleDueyActions>();
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("SELECT * FROM dueypackages WHERE RecieverId = ?");
            ps.setInt(1, chr.getId());
            rs = ps.executeQuery();
            while (rs.next()) {
                MapleDueyActions dueypack = getItemByPID(rs.getInt("packageid"));
                dueypack.setSender(rs.getString("SenderName"));
                dueypack.setMesos(rs.getInt("Mesos"));
                dueypack.setSentTime(rs.getLong("TimeStamp"));
                dueypack.setContent(rs.getString("content"));
                dueypack.setQuick(rs.getInt("Quick") > 0);
                packages.add(dueypack);
            }
            rs.close();
            ps.close();
            return packages;
        } catch (SQLException se) {
            se.printStackTrace();
            return null;
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (rs != null) {
                try {
                    rs.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
        }
    }

    public static final MapleDueyActions loadSingleItem(final int packageid, final int charid) {
        List<MapleDueyActions> packages = new LinkedList<MapleDueyActions>();
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("SELECT * FROM dueypackages WHERE PackageId = ? and RecieverId = ?");
            ps.setInt(1, packageid);
            ps.setInt(2, charid);
            rs = ps.executeQuery();

            if (rs.next()) {
                MapleDueyActions dueypack = getItemByPID(packageid);
                dueypack.setSender(rs.getString("SenderName"));
                dueypack.setMesos(rs.getInt("Mesos"));
                dueypack.setSentTime(rs.getLong("TimeStamp"));
                dueypack.setContent(rs.getString("content"));
                dueypack.setQuick(rs.getInt("Quick") > 0);
                packages.add(dueypack);
                return dueypack;
            } else {
                rs.close();
                ps.close();
                return null;
            }
        } catch (SQLException se) {
//	    se.printStackTrace();
            return null;
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (rs != null) {
                try {
                    rs.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
        }
    }

    public static final void reciveMsg(final MapleClient c, final int recipientId) {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("UPDATE dueypackages SET Checked = 0 where RecieverId = ?");
            ps.setInt(1, recipientId);
            ps.executeUpdate();
            ps.close();
        } catch (SQLException se) {
            se.printStackTrace();
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
        }
    }

    public static final void removeItemFromDB(final int packageid, final int charid) {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("DELETE FROM dueypackages WHERE PackageId = ? and RecieverId = ?");
            ps.setInt(1, packageid);
            ps.setInt(2, charid);
            ps.executeUpdate();
            ps.close();
        } catch (SQLException se) {
            se.printStackTrace();
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
        }
    }

    private static final MapleDueyActions getItemByPID(final int packageid) {
        try {
            Map<Long, Pair<Item, MapleInventoryType>> iter = ItemLoader.送货道具.loadItems(false, packageid);
            if (iter != null && iter.size() > 0) {
                for (Pair<Item, MapleInventoryType> i : iter.values()) {
                    return new MapleDueyActions(packageid, i.getLeft());
                }
            }
        } catch (Exception se) {
            se.printStackTrace();
        }
        return new MapleDueyActions(packageid);
    }
}

############################################################


    /*
    送货员相关
    */
    public static final int getAccByName(final String name) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = DatabaseConnection.getConnection();
            ps = con.prepareStatement("SELECT accountid FROM characters WHERE name LIKE ?");
            ps.setString(1, name);
            rs = ps.executeQuery();

            if (!rs.next()) {
                rs.close();
                ps.close();
                return -1;
            }
            final int id = rs.getInt("accountid");
            rs.close();
            ps.close();

            return id;
        } catch (SQLException e) {
            System.err.println("error 'getIdByName' " + e);
        } finally {
            if (con != null) {
                try {
                    con.close();
                } catch (Exception e) {
                }
            }
            if (rs != null) {
                try {
                    rs.close();
                } catch (Exception e) {
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (Exception e) {
                }
            }
        }
        return -1;
    }

###########################################################################

package server;

import client.inventory.Item;

public class MapleDueyActions {

    private String sender = null;
    private Item item = null;
    private int mesos = 0;
    private int quantity = 1;
    private long sentTime;
    private int packageId = 0;
    private String content = null;
    private boolean quick = false;

    public MapleDueyActions(int pId, Item item) {
        this.item = item;
        this.quantity = item.getQuantity();
        packageId = pId;
    }

    public MapleDueyActions(int pId) { // meso only package
        this.packageId = pId;
    }

    public void setContent(String s) {
        this.content = s;
    }

    public long getExpireTime() {
        if (isQuick()) {
            return getSentTime() + (30 * 86400000L);
        } else {
            return getSentTime() + 12 * 3600000L + (30 * 86400000L);
        }
    }

    public boolean canReceive() {
        return (isQuick() || getSentTime() + 12 * 3600000L < System.currentTimeMillis());
    }

    public boolean isExpire() {
        if (isQuick()) {
            return getSentTime() + 30 * 86400000L < System.currentTimeMillis();
        } else {
            return getSentTime() + 12 * 3600000L + 30 * 86400000L < System.currentTimeMillis();
        }
    }

    public String getContent() {
        return content;
    }

    public void setQuick(boolean bln) {
        this.quick = bln;
    }

    public boolean isQuick() {
        return quick;
    }

    public String getSender() {
        return sender;
    }

    public void setSender(String name) {
        sender = name;
    }

    public Item getItem() {
        return item;
    }

    public int getMesos() {
        return mesos;
    }

    public void setMesos(int set) {
        mesos = set;
    }

    public int getQuantity() {
        return quantity;
    }

    public int getPackageId() {
        return packageId;
    }

    /*    public boolean isExpired() {
     Calendar cal1 = Calendar.getInstance();
     cal1.set(year, month - 1, day);
     long diff = System.currentTimeMillis() - cal1.getTimeInMillis();
     int diffDays = (int) Math.abs(diff / (24 * 60 * 60 * 1000));
     return diffDays > 30;
     }

     public long sentTimeInMilliseconds() {
     Calendar cal = Calendar.getInstance();
     cal.set(year, month, day);
     return cal.getTimeInMillis();
     }*/
    public void setSentTime(long sentTime) {
        this.sentTime = sentTime;
    }

    public long getSentTime() {
        return sentTime;
    }
}

############################################################


############################################################


############################################################


############################################################


############################################################