Class MovementDAO

java.lang.Object
ru.bgcrm.dao.CommonDAO
org.bgerp.plugin.inventoru.dao.MovementDAO
public class MovementDAO extends CommonDAO
DAO for stock Movement records and inventoru_balance. Movements are append-only — never updated or deleted. Balance is maintained via INSERT ... ON DUPLICATE KEY UPDATE.

  • Constructor Details

    • MovementDAO

      public MovementDAO(Connection con)

  • Method Details

    • getById

      public Movement getById(long id) throws SQLException
      Throws:
      SQLException

    • getReturnable

      public BigDecimal getReturnable(int storeId, int itemId, int userId) throws SQLException
      How much of a position a user may still return to a store: what was written off from it under the user's own reserves — materials issued to them for work — less the write-offs reversed since and what the user has returned already. A return used to take any quantity, and an installer put stock on his store out of thin air.
      Throws:
      SQLException

    • isActiveReserve

      public boolean isActiveReserve(long reserveId) throws SQLException
      Returns true if the given reserve movement is still active, i.e. no unreserve/writeoff already references it via ref_movement_id. Used to reject a duplicate/stale unreserve request instead of silently recording a phantom cancellation on top of an already-settled reserve.
      Throws:
      SQLException

    • getActiveReserveProcessId

      public Integer getActiveReserveProcessId(String serial) throws SQLException
      The process holding an active reserve of the unit with this serial — a reserve of a serial tracked position names the unit, and the write-off made from it later by the 1C export takes exactly that unit.
      Returns:
      the process id (0 for a reserve without a process), null when none
      Throws:
      SQLException

    • checkReservable

      public String checkReservable(int itemId, int storeId, String serial) throws SQLException
      Whether the unit with this serial can be reserved on the store under the position: it stands there, under it, alone with its serial, and no other process holds it.
      Returns:
      why not, null when it can
      Throws:
      SQLException

    • getFreeSerials

      public Map<String, List<String>> getFreeSerials(Collection<Integer> storeIds) throws SQLException
      Serials of the units counted on the stores that no reservation holds — what an installer can pick on the process tab, as storeId_itemId → serials.
      Throws:
      SQLException

    • findUnit

      public MovementDAO.UnitPlace findUnit(String serial) throws SQLException
      Not DeviceDAO.getBySerial / findDeviceIdBySerial: both take the first row, and here a second unit with the same serial — there is no unique key on it — is exactly what has to be seen.
      Throws:
      SQLException

    • getListByStore

      public List<Movement> getListByStore(int storeId, int limit) throws SQLException
      Throws:
      SQLException

    • getListByProcess

      public List<Movement> getListByProcess(int processId) throws SQLException
      Throws:
      SQLException

    • append

      public void append(Movement m) throws SQLException
      Appends a movement record and updates the balance accordingly. For "reserve" adds to reserved; for "unreserve"/"writeoff"/"return" adjusts reserved/quantity.
      Parameters:
      m - movement to record
      Throws:
      IllegalStateException - if the operation would make balance negative
      SQLException

    • checkStoreAndItemAlive

      public void checkStoreAndItemAlive(int storeId, int itemId) throws SQLException
      Refuses a store or a position that does not exist or is deleted: stock moved there lands where no screen shows it. Shared by the movement actions — the admin receipt and correction screen and the record action make the same check.
      Throws:
      SQLException

    • transfer

      public void transfer(int fromStoreId, int toStoreId, int itemId, BigDecimal qty, int processId, int userId, String serialNumber, String comment) throws SQLException
      Moves quantity from one store to another as a linked pair of movements (append-only, same pattern as reserve/unreserve and writeoff/receipt-reversal): the source row (type=transfer) debits fromStoreId and records toStoreId in related_store_id, the destination row (type=transfer_in) credits toStoreId, records fromStoreId in related_store_id, and links back via ref_movement_id — so the movement list can show "→ Title"/"← Title" on each side and the two legs of any transfer can always be found from either one. Caller is responsible for the available-quantity check and for committing.
      Throws:
      SQLException

    • getBalanceItems

      public List<Map<String,Object>> getBalanceItems(Collection<Integer> storeIds) throws SQLException
      Returns balance data for given store IDs as a flat list of maps. Each map has keys: storeId, itemId, quantity, reserved. Used for JS-driven balance hints in the process materials tab.
      Throws:
      SQLException

    • getBalanceList

      public List<Map<String,Object>> getBalanceList(int storeId) throws SQLException
      Returns balance for a store as list of maps with keys: itemId, itemTitle, itemTypeId, quantity, reserved. Ordered by item title. Only rows with quantity > 0 or reserved > 0. itemTypeId lets the caller split consumables from asset-kind items (see ItemTypeProperties) without a second query.
      Throws:
      SQLException

    • fromRs

      public static Movement fromRs(ResultSet rs) throws SQLException
      Throws:
      SQLException