Store Container + TE

public abstract class TEStorage extends TileEntity implements IInventory {

    @Override
    public void readFromNBT(NBTTagCompound tag) {
        super.readFromNBT(tag);
        NBTTagList inv = tag.getTagList("Items",10);

        for (int i = 0; i < inv.tagCount(); ++i) {
            NBTTagCompound item = inv.getCompoundTagAt(i);
            int j = item.getByte("Slot") & 255;

            if (j >= 0 && j < getSizeInventory()) {
                setInventorySlotContents(j,ItemStack.loadItemStackFromNBT(item));
            }
        }
    }

    @Override
    public void writeToNBT(NBTTagCompound tag) {
        super.writeToNBT(tag);
        NBTTagList inv = new NBTTagList();

        for (int i = 0; i < getSizeInventory(); i++) {
            ItemStack stack = getStackInSlot(i);
            if (stack !=null){
                NBTTagCompound item = new NBTTagCompound();
                item.setByte("Slot", (byte)i);
                stack.writeToNBT(item);
                inv.appendTag(item);
            }
        }

        tag.setTag("Items",inv);

    }

    @Override public abstract int getSizeInventory();
    @Override public abstract ItemStack getStackInSlot(int slot);
    @Override public abstract ItemStack decrStackSize(int slot, int amt);
    @Override public abstract ItemStack getStackInSlotOnClosing(int slot);
    @Override public abstract void setInventorySlotContents(int slot, ItemStack stack);
    @Override public abstract String getInventoryName();
    @Override public abstract boolean hasCustomInventoryName();
    @Override public abstract int getInventoryStackLimit();
    @Override public abstract boolean isUseableByPlayer(EntityPlayer player);
    @Override public abstract void openInventory();
    @Override public abstract void closeInventory();
    @Override public abstract boolean isItemValidForSlot(int slot, ItemStack stack);
}

public class TEShop extends TEStorage{

    private ItemStack[] inv = new ItemStack[5];
    private UUID owner;

    public void setOwner(UUID owner) {
        this.owner = owner;
        this.markDirty();
    }
    public UUID getOwner() {return owner;}

    public float getCardCredit(){
        if (inv[0] == null)return 0f;
        else if (inv[0].getItem() == ModItems.creditCard){
            if (inv[0].hasTagCompound()){
                BankAccount account = BankAccount.fromNBT(worldObj,inv[0].getTagCompound().getCompoundTag(NBTTags.Card.ACCOUNTS_TAG),null);
                return account.getCredit();
            }
        }
        return 0f;
    }

    @Override
    public void writeToNBT(NBTTagCompound tag) {
        super.writeToNBT(tag);
        tag.setTag(NBTTags.Card.UUID_OWNER_TAG, Converters.getTagFromUUID(owner));
    }

    @Override
    public void readFromNBT(NBTTagCompound tag) {
        super.readFromNBT(tag);
        owner = Converters.getUUIDFromTag(tag.getCompoundTag(NBTTags.Card.UUID_OWNER_TAG));
    }

    @Override
    public int getSizeInventory() {
        return inv.length;
    }

    @Override
    public ItemStack getStackInSlot(int slot) {
        return inv[slot];
    }

    @Override
    public ItemStack decrStackSize(int slot, int amt) {
        ItemStack stack = getStackInSlot(slot);
        if (stack != null) {
            if (stack.stackSize <= amt) {
                setInventorySlotContents(slot, null);
            } else {
                stack = stack.splitStack(amt);
                if (stack.stackSize == 0) {
                    setInventorySlotContents(slot, null);
                }
            }
        }
        return stack;
    }
    @Override
    public ItemStack getStackInSlotOnClosing(int slot) {
        return getStackInSlot(slot);
    }

    @Override
    public void setInventorySlotContents(int slot, ItemStack stack) {
        inv[slot] = stack;
    }

    @Override public String getInventoryName() {return "Store";}
    @Override public boolean hasCustomInventoryName() {return false;}
    @Override public int getInventoryStackLimit() {return 64;}
    @Override public boolean isUseableByPlayer(EntityPlayer player) {return true;}
    @Override public void openInventory() {}
    @Override public void closeInventory() {}
    @Override public boolean isItemValidForSlot(int slot, ItemStack stack) {return true;}
}

public class BlockShop extends BlockMTContainer {
    public BlockShop(){
        super();
        this.setBlockName("shop");
    }

    @Override
    public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase livingBase, ItemStack stack) {
        if (livingBase instanceof EntityPlayer){
            EntityPlayer player = (EntityPlayer) livingBase;
            TEShop shop = (TEShop) world.getTileEntity(x,y,z);
            shop.setOwner(player.getGameProfile().getId());
        }
    }

    @Override
    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int meta, float hitX, float hitY, float hitZ) {
        player.openGui(MoneyMod.instance,1,world,x,y,z);
        return super.onBlockActivated(world, x, y, z, player, meta, hitX, hitY, hitZ);
    }

    @Override
    public TileEntity createNewTileEntity(World world, int meta) {
        return new TEShop();
    }
}

public static class StoreContainer extends Container {
        private IInventory playerInv, storeInv;

        public StoreContainer(EntityPlayer player, final IInventory storeInv){
            super();
            this.playerInv = player.inventory;
            this.storeInv = storeInv;

            //((TEShop) storeInv).setPlayer(player);

            storeInv.openInventory();

            int i = (6 - 4) * 18 + 1;
            int j;
            int k;

            this.addSlotToContainer(new Slot(storeInv, 0, 8, 18));
            for (j = 0; j < 4; j++) {
                this.addSlotToContainer(new Slot(storeInv, j + 1, 8 + 22, 18 + (22 * (j))){
                    @SuppressWarnings("Contract")
                    @Override
                    public boolean canTakeStack(EntityPlayer player) {
                        return ((TEShop) storeInv).getOwner() != null &&
                                (((TEShop) storeInv).getOwner().equals(player.getGameProfile().getId()) ||
                                        ((TEShop) storeInv).getCardCredit() >= 64f);
                    }
                });
            }


            for (j = 0; j < 3; ++j) {
                for (k = 0; k < 9; ++k) {
                    this.addSlotToContainer(new Slot(playerInv, k + j * 9 + 9, 8 + k * 18, 103 + j * 18 + i));
                }
            }

            for (j = 0; j < 9; ++j) {
                this.addSlotToContainer(new Slot(playerInv, j, 8 + j * 18, 161 + i));
            }
        }

        @Override
        public ItemStack transferStackInSlot(EntityPlayer player, int slot) {
            ItemStack stack = null;
            Slot slotObject = (Slot) inventorySlots.get(slot);

            //null checks and checks if the item can be stacked (maxStackSize > 1)
            if (slotObject != null && slotObject.getHasStack()) {
                ItemStack stackInSlot = slotObject.getStack();
                stack = stackInSlot.copy();

                //merges the item into player inventory since its in the tileEntity
                if (slot < storeInv.getSizeInventory()) {
                    if (!this.mergeItemStack(stackInSlot, storeInv.getSizeInventory(), 36+ storeInv.getSizeInventory(), true)) {
                        return null;
                    }
                }
                //places it into the tileEntity is possible since its in the player inventory
                else if (!this.mergeItemStack(stackInSlot, 0, storeInv.getSizeInventory(), false)) {
                    return null;
                }

                if (stackInSlot.stackSize == 0) {
                    slotObject.putStack(null);
                } else {
                    slotObject.onSlotChanged();
                }

                if (stackInSlot.stackSize == stack.stackSize) {
                    return null;
                }
                slotObject.onPickupFromSlot(player, stackInSlot);
            }
            return stack;
        }

        @Override public boolean canInteractWith(EntityPlayer player) {return true;}

        @Override
        public boolean isPlayerNotUsingContainer(EntityPlayer p_75129_1_) {
            return super.isPlayerNotUsingContainer(p_75129_1_);
        }

        @Override
        public void onContainerClosed(EntityPlayer player) {
            storeInv.closeInventory();
        }
    }