Unit-api/oracle_API/StockTakingUnitDet.apy

-----------------------------------------------------------------------------
--
--  Logical unit: StockTakingUnitDet
--
--  Purpose:
--
--  IFS/Design Template Version 2.2
--
--  Date    Sign  History
--  ------  ----  -----------------------------------------------------------
-----------------------------------------------------------------------------

DEFINE MODULE        = INCON
DEFINE LU            = StockTakingUnitDet
DEFINE TABLE         = STOCK_TAKING_UNIT_DET_TAB
DEFINE VIEW          = STOCK_TAKING_UNIT_DET
DEFINE PKG           = STOCK_TAKING_UNIT_DET_API

DEFINE OBJID         = rowid
DEFINE OBJVERSION    = "ltrim(lpad(to_char(rowversion,'YYYYMMDDHH24MISS'),2000))"

-----------------------------------------------------------------------------
-------------------- VIEWS FOR SELECTS --------------------------------------
-----------------------------------------------------------------------------

PROMPT Creating &VIEW view

CREATE OR REPLACE VIEW &VIEW AS
SELECT company                        company,
       stock_taking_unit_id           stock_taking_unit_id,
       mesin                          mesin,
       flag_reject                    flag_reject,
       keterangan                     keterangan,
       &OBJID                         objid,
       &OBJVERSION                    objversion
FROM   stock_taking_unit_det_tab
WITH   read only;

COMMENT ON TABLE &VIEW
   IS 'LU=&LU^PROMPT=Stock Taking Unit Det^MODULE=&MODULE^';

COMMENT ON COLUMN &VIEW..company
   IS 'FLAGS=PMI--^DATATYPE=STRING(50)/UPPERCASE^PROMPT=Company^';
COMMENT ON COLUMN &VIEW..stock_taking_unit_id
   IS 'FLAGS=PMI--^DATATYPE=STRING(50)/UPPERCASE^PROMPT=Stock Taking Unit Id^REF=StockTakingUnit(company)^';
COMMENT ON COLUMN &VIEW..mesin
   IS 'FLAGS=KMI-L^DATATYPE=STRING(30)/UPPERCASE^PROMPT=Mesin^REF=StokFaktur(company)^';
COMMENT ON COLUMN &VIEW..flag_reject
   IS 'FLAGS=AMIUL^DATATYPE=BOOLEAN^PROMPT=Flag Reject^';
COMMENT ON COLUMN &VIEW..keterangan
   IS 'FLAGS=A-IUL^DATATYPE=STRING(200)^PROMPT=Keterangan^';

-----------------------------------------------------------------------------
-------------------- PACKAGES FOR METHODS -----------------------------------
-----------------------------------------------------------------------------

PROMPT Creating &PKG implementation

CREATE OR REPLACE PACKAGE BODY &PKG IS

-----------------------------------------------------------------------------
-------------------- LU SPECIFIC IMPLEMENTATION METHOD DECLARATIONS ---------
-----------------------------------------------------------------------------


-----------------------------------------------------------------------------
-------------------- IMPLEMENTATION BASE METHODS ----------------------------
-----------------------------------------------------------------------------
-- Lock_By_Id___
--    Client-support to lock a specific instance of the logical unit.
--
-- Lock_By_Keys___
--    Server support to lock a specific instance of the logical unit.
--
-- Get_Object_By_Id___
--    Get LU-record from the database with a specified object identity.
--
-- Get_Object_By_Keys___
--    Get LU-record from the database with specified key columns.
--
-- Check_Exist___
--    Check if a specific LU-instance already exist in the database.
--
-- Get_Id_Version_By_Keys___
--    Get the current OBJID and OBJVERSION for a specific LU-instance.
-----------------------------------------------------------------------------

FUNCTION Lock_By_Id___ (
   objid_      IN  VARCHAR2,
   objversion_ IN  VARCHAR2 ) RETURN &TABLE%ROWTYPE
IS
   row_changed EXCEPTION;
   row_deleted EXCEPTION;
   row_locked  EXCEPTION;
   PRAGMA      exception_init(row_locked, -0054);
   rec_        &TABLE%ROWTYPE;
   dummy_      NUMBER;
   CURSOR lock_control IS
      SELECT *
      FROM   &TABLE
      WHERE  &OBJID = objid_
      AND    &OBJVERSION = objversion_
      FOR UPDATE NOWAIT;
   CURSOR exist_control IS
      SELECT 1
      FROM   &TABLE
      WHERE  &OBJID = objid_;
BEGIN
   OPEN lock_control;
   FETCH lock_control INTO rec_;
   IF (lock_control%FOUND) THEN
      CLOSE lock_control;
      RETURN rec_;
   END IF;
   CLOSE lock_control;
   OPEN exist_control;
   FETCH exist_control INTO dummy_;
   IF (exist_control%FOUND) THEN
      CLOSE exist_control;
      RAISE row_changed;
   ELSE
      CLOSE exist_control;
      RAISE row_deleted;
   END IF;
EXCEPTION
   WHEN row_locked THEN
      Error_SYS.Record_Locked(lu_name_);
   WHEN row_changed THEN
      Error_SYS.Record_Modified(lu_name_);
   WHEN row_deleted THEN
      Error_SYS.Record_Removed(lu_name_);
END Lock_By_Id___;

FUNCTION Lock_By_Keys___ (
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2 ) RETURN &TABLE%ROWTYPE
IS
   row_deleted EXCEPTION;
   rec_        &TABLE%ROWTYPE;
   CURSOR lock_control IS
      SELECT *
      FROM  &TABLE
      WHERE company = company_
      AND   stock_taking_unit_id = stock_taking_unit_id_
      AND   mesin = mesin_
      FOR UPDATE;
BEGIN
   OPEN lock_control;
   FETCH lock_control INTO rec_;
   IF (lock_control%FOUND) THEN
      CLOSE lock_control;
      RETURN rec_;
   ELSE
      CLOSE lock_control;
      RAISE row_deleted;
   END IF;
EXCEPTION
   WHEN row_deleted THEN
      Error_SYS.Record_Removed(lu_name_);
END Lock_By_Keys___;

FUNCTION Get_Object_By_Id___ (
   objid_ IN VARCHAR2 ) RETURN &TABLE%ROWTYPE
IS
   lu_rec_ &TABLE%ROWTYPE;
   CURSOR getrec IS
      SELECT *
      FROM   &TABLE
      WHERE  &OBJID = objid_;
BEGIN
   OPEN getrec;
   FETCH getrec INTO lu_rec_;
   IF (getrec%NOTFOUND) THEN
      CLOSE getrec;
      Error_SYS.Record_Removed(lu_name_);
   END IF;
   CLOSE getrec;
   RETURN(lu_rec_);
END Get_Object_By_Id___;


FUNCTION Get_Object_By_Keys___ (
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2 ) RETURN &TABLE%ROWTYPE
IS
   lu_rec_ &TABLE%ROWTYPE;
   CURSOR getrec IS
      SELECT *
      FROM  &TABLE
      WHERE company = company_
      AND   stock_taking_unit_id = stock_taking_unit_id_
      AND   mesin = mesin_;
BEGIN
   OPEN getrec;
   FETCH getrec INTO lu_rec_;
   CLOSE getrec;
   RETURN(lu_rec_);
END Get_Object_By_Keys___;

FUNCTION Check_Exist___ (
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2 ) RETURN BOOLEAN
IS
   dummy_ NUMBER;
   CURSOR exist_control IS
      SELECT 1
      FROM   &TABLE
      WHERE company = company_
      AND   stock_taking_unit_id = stock_taking_unit_id_
      AND   mesin = mesin_;
BEGIN
   OPEN exist_control;
   FETCH exist_control INTO dummy_;
   IF (exist_control%FOUND) THEN
      CLOSE exist_control;
      RETURN(TRUE);
   END IF;
   CLOSE exist_control;
   RETURN(FALSE);
END Check_Exist___;

PROCEDURE Get_Id_Version_By_Keys___ (
   objid_      IN OUT VARCHAR2,
   objversion_ IN OUT VARCHAR2,
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2)
IS
   CURSOR get_version IS
   SELECT &OBJID, &OBJVERSION
      FROM  &TABLE
      WHERE company = company_
      AND   stock_taking_unit_id = stock_taking_unit_id_
      AND   mesin = mesin_;
BEGIN
   OPEN get_version;
   FETCH get_version INTO objid_, objversion_;
   CLOSE get_version;
END Get_Id_Version_By_Keys___;

-----------------------------------------------------------------------------
-------------------- IMPLEMENTATION BASE METHODS FOR INSERT -----------------
-----------------------------------------------------------------------------
-- Prepare_Insert___
--    Set all default values for a new instance (ON-NEW-RECORD) of this
--    logical unit by calling procedure Add_Attr.
--
-- Unpack_Check_Insert___
--    Unpack the attribute list, check all attributes from the client
--    and generate all default values before creation of the new object.
--
-- Insert___
--    Insert a new LU-instance into the database and return the values
--    for OBJID and OBJVERSION.
-----------------------------------------------------------------------------

PROCEDURE Prepare_Insert___ (
   attr_ IN OUT VARCHAR2 )
IS
BEGIN
   Client_SYS.Clear_Attr(attr_);
END Prepare_Insert___;


PROCEDURE Unpack_Check_Insert___ (
   attr_   IN OUT VARCHAR2,
   newrec_ IN OUT &TABLE%ROWTYPE )
IS
   ptr_   NUMBER;
   name_  VARCHAR2(30);
   value_ VARCHAR2(2000);
BEGIN
   ptr_ := NULL;
   WHILE (Client_SYS.Get_Next_From_Attr(attr_, ptr_, name_, value_)) LOOP
      IF (name_ = 'COMPANY') THEN
         newrec_.company := value_;
      ELSIF (name_ = 'STOCK_TAKING_UNIT_ID') THEN
         newrec_.stock_taking_unit_id := value_;
         Stock_Taking_Unit_API.Exist(newrec_.company, newrec_.stock_taking_unit_id);
      ELSIF (name_ = 'MESIN') THEN
         newrec_.mesin := value_;
         Stok_Faktur_API.Exist(newrec_.company, newrec_.mesin);
      ELSIF (name_ = 'FLAG_REJECT') THEN
         newrec_.flag_reject := value_;
      ELSIF (name_ = 'KETERANGAN') THEN
         newrec_.keterangan := value_;
      ELSE
         Error_SYS.Item_Not_Exist(lu_name_, name_, value_);
      END IF;
   END LOOP;
   Client_SYS.Clear_Attr(attr_);
   Error_SYS.Check_Not_Null(lu_name_, 'COMPANY', newrec_.company);
   Error_SYS.Check_Not_Null(lu_name_, 'STOCK_TAKING_UNIT_ID', newrec_.stock_taking_unit_id);
   Error_SYS.Check_Not_Null(lu_name_, 'MESIN', newrec_.mesin);
   Error_SYS.Check_Not_Null(lu_name_, 'FLAG_REJECT', newrec_.flag_reject);
EXCEPTION
   WHEN value_error THEN
      Error_SYS.Item_Format(lu_name_, name_, value_);
END Unpack_Check_Insert___;


PROCEDURE Insert___ (
   objid_      OUT    VARCHAR2,
   objversion_ OUT    VARCHAR2,
   newrec_     IN OUT &TABLE%ROWTYPE,
   attr_       IN OUT VARCHAR2 )
IS
BEGIN
   newrec_.rowversion := sysdate;
   objversion_ := to_char(newrec_.rowversion,'YYYYMMDDHH24MISS');
   INSERT
      INTO stock_taking_unit_det_tab (
         company,
         stock_taking_unit_id,
         mesin,
         flag_reject,
         keterangan,
         rowversion)
      VALUES (
         newrec_.company,
         newrec_.stock_taking_unit_id,
         newrec_.mesin,
         newrec_.flag_reject,
         newrec_.keterangan,
         newrec_.rowversion);
   objid_ := DBMS_sql.last_row_id;
--   SELECT &OBJID
--      INTO  objid_
--      FROM  &TABLE
--      WHERE company = newrec_.company
--      AND   stock_taking_unit_id = newrec_.stock_taking_unit_id
--      AND   mesin = newrec_.mesin;

EXCEPTION
   WHEN dup_val_on_index THEN
      Error_SYS.Record_Exist(lu_name_);
END Insert___;

-----------------------------------------------------------------------------
-------------------- IMPLEMENTATION BASE METHODS FOR UPDATE -----------------
-----------------------------------------------------------------------------
-- Unpack_Check_Update___
--    Unpack the attribute list, check all attributes from the client
--    and generate all default values before modifying the object.
--
-- Update___
--    Update an existing LU-instance in the database and return the
--    the new OBJVERSION.
-----------------------------------------------------------------------------

PROCEDURE Unpack_Check_Update___ (
   attr_   IN OUT VARCHAR2,
   newrec_ IN OUT &TABLE%ROWTYPE,
   objid_  IN     VARCHAR2 )
IS
   ptr_   NUMBER;
   name_  VARCHAR2(30);
   value_ VARCHAR2(2000);
BEGIN
   ptr_ := NULL;
   WHILE (Client_SYS.Get_Next_From_Attr(attr_, ptr_, name_, value_)) LOOP
      IF (name_ = 'COMPANY') THEN
         Error_SYS.Item_Update(lu_name_, 'COMPANY');
      ELSIF (name_ = 'STOCK_TAKING_UNIT_ID') THEN
         Error_SYS.Item_Update(lu_name_, 'STOCK_TAKING_UNIT_ID');
      ELSIF (name_ = 'MESIN') THEN
         Error_SYS.Item_Update(lu_name_, 'MESIN');
      ELSIF (name_ = 'FLAG_REJECT') THEN
         newrec_.flag_reject := value_;
      ELSIF (name_ = 'KETERANGAN') THEN
         newrec_.keterangan := value_;
      ELSE
         Error_SYS.Item_Not_Exist(lu_name_, name_, value_);
      END IF;
   END LOOP;
   Client_SYS.Clear_Attr(attr_);
   Error_SYS.Check_Not_Null(lu_name_, 'FLAG_REJECT', newrec_.flag_reject);
EXCEPTION
   WHEN value_error THEN
      Error_SYS.Item_Format(lu_name_, name_, value_);
END Unpack_Check_Update___;


PROCEDURE Update___ (
   objid_      IN     VARCHAR2,
   oldrec_     IN     &TABLE%ROWTYPE,
   newrec_     IN OUT &TABLE%ROWTYPE,
   attr_       IN OUT VARCHAR2,
   objversion_ IN OUT VARCHAR2,
   by_keys_    IN BOOLEAN DEFAULT FALSE )
IS
BEGIN
   newrec_.rowversion := sysdate;
   objversion_ := to_char(newrec_.rowversion,'YYYYMMDDHH24MISS');
   IF by_keys_ THEN
      UPDATE stock_taking_unit_det_tab
      SET company = newrec_.company,
          stock_taking_unit_id = newrec_.stock_taking_unit_id,
          mesin = newrec_.mesin,
          flag_reject = newrec_.flag_reject,
          keterangan = newrec_.keterangan,
          rowversion = newrec_.rowversion
      WHERE company = newrec_.company
      AND   stock_taking_unit_id = newrec_.stock_taking_unit_id
      AND   mesin = newrec_.mesin;
   ELSE
      UPDATE stock_taking_unit_det_tab
      SET company = newrec_.company,
          stock_taking_unit_id = newrec_.stock_taking_unit_id,
          mesin = newrec_.mesin,
          flag_reject = newrec_.flag_reject,
          keterangan = newrec_.keterangan,
          rowversion = newrec_.rowversion
      WHERE &OBJID = objid_;
   END IF;
EXCEPTION
   WHEN dup_val_on_index THEN
      Error_SYS.Record_Exist(lu_name_);
END Update___;

-----------------------------------------------------------------------------
-------------------- IMPLEMENTATION BASE METHODS FOR DELETE -----------------
-----------------------------------------------------------------------------
-- Check_Delete___
--    Checks whether a specific LU-record may be removed or not.
--    The procedure should check business rules like attribute values
--    as well as database constraints (defined or not).
--
-- Delete___
--    Deletion of the specific LU-object from the database.
-----------------------------------------------------------------------------

PROCEDURE Check_Delete___ (
   remrec_ IN &TABLE%ROWTYPE )
IS
   key_ VARCHAR2(2000);
BEGIN
   key_ := remrec_.company || '^' || remrec_.stock_taking_unit_id || '^' || remrec_.mesin || '^';
   Reference_SYS.Check_Restricted_Delete(lu_name_, key_);
END Check_Delete___;


PROCEDURE Delete___ (
   objid_  IN VARCHAR2,
   remrec_ IN &TABLE%ROWTYPE )
IS
   key_ VARCHAR2(2000);
BEGIN
   key_ := remrec_.company || '^' || remrec_.stock_taking_unit_id || '^' || remrec_.mesin || '^';
   Reference_SYS.Do_Cascade_Delete(lu_name_, key_);
   DELETE
      FROM  stock_taking_unit_det_tab
      WHERE &OBJID = objid_;
END Delete___;

-----------------------------------------------------------------------------
-------------------- PRIVATE BASE METHODS -----------------------------------
-----------------------------------------------------------------------------
-- Lock__
--    Client-support to lock a specific instance of the logical unit.
--
-- New__
--    Client-support interface to create LU instances.
--       action_ = 'PREPARE'
--          Default values and handle of information to client.
--          The default values are set in procedure Prepare_Insert___.
--       action_ = 'CHECK'
--          Check all attributes before creating new object and handle of
--          information to client. The attribute list is unpacked, checked
--          and prepared (defaults) in procedure Unpack_Check_Insert___.
--       action_ = 'DO'
--          Creation of new instances of the logical unit and handle of
--          information to client. The attribute list is unpacked, checked
--          and prepared (defaults) in procedure Unpack_Check_Insert___
--          before calling procedure Insert___.
--
-- Modify__
--    Client-support interface to modify attributes for LU instances.
--       action_ = 'CHECK'
--          Check all attributes before modifying an existing object and
--          handle of information to client. The attribute list is unpacked,
--          checked and prepared(defaults) in procedure Unpack_Check_Update___.
--       action_ = 'DO'
--          Modification of an existing instance of the logical unit. The
--          procedure unpacks the attributes, checks all values before
--          procedure Update___ is called.
--
-- Remove__
--    Client-support interface to remove LU instances.
--       action_ = 'CHECK'
--          Check whether a specific LU-instance may be removed or not.
--          The procedure fetches the complete record by calling procedure
--          Get_Object_By_Id___. Then the check is made by calling procedure
--          Check_Delete___.
--       action_ = 'DO'
--          Remove an existing instance of the logical unit. The procedure
--          fetches the complete LU-record, checks for a delete and then
--          deletes the record by calling procedure Delete___.
-----------------------------------------------------------------------------

PROCEDURE Lock__ (
   info_       OUT VARCHAR2,
   objid_      IN  VARCHAR2,
   objversion_ IN  VARCHAR2 )
IS
   dummy_ &TABLE%ROWTYPE;
BEGIN
   General_SYS.Init_Method(lu_name_, '&PKG', 'Lock__');
   dummy_ := Lock_By_Id___(objid_, objversion_);
   info_ := Client_SYS.Get_All_Info;
END Lock__;


PROCEDURE New__ (
   info_       OUT    VARCHAR2,
   objid_      OUT    VARCHAR2,
   objversion_ OUT    VARCHAR2,
   attr_       IN OUT VARCHAR2,
   action_     IN     VARCHAR2 )
IS
   newrec_ &TABLE%ROWTYPE;
BEGIN
   General_SYS.Init_Method(lu_name_, '&PKG', 'New__');
   IF (action_ = 'PREPARE') THEN
      Prepare_Insert___(attr_);
   ELSIF (action_ = 'CHECK') THEN
      Unpack_Check_Insert___(attr_, newrec_);
   ELSIF (action_ = 'DO') THEN
      Unpack_Check_Insert___(attr_, newrec_);
      Insert___(objid_, objversion_, newrec_, attr_);
   END IF;
   info_ := Client_SYS.Get_All_Info;
END New__;


PROCEDURE Modify__ (
   info_       OUT    VARCHAR2,
   objid_      IN     VARCHAR2,
   objversion_ IN OUT VARCHAR2,
   attr_       IN OUT VARCHAR2,
   action_     IN     VARCHAR2 )
IS
   oldrec_ &TABLE%ROWTYPE;
   newrec_ &TABLE%ROWTYPE;
BEGIN
   General_SYS.Init_Method(lu_name_, '&PKG', 'Modify__');
   IF (action_ = 'CHECK') THEN
      newrec_ := Get_Object_By_Id___(objid_);
      Unpack_Check_Update___(attr_, newrec_, objid_);
   ELSIF (action_ = 'DO') THEN
      oldrec_ := Lock_By_Id___(objid_, objversion_);
      newrec_ := oldrec_;
      Unpack_Check_Update___(attr_, newrec_, objid_);
      Update___(objid_, oldrec_, newrec_, attr_, objversion_);
   END IF;
   info_ := Client_SYS.Get_All_Info;
END Modify__;


PROCEDURE Remove__ (
   info_       OUT VARCHAR2,
   objid_      IN  VARCHAR2,
   objversion_ IN  VARCHAR2,
   action_     IN  VARCHAR2 )
IS
   remrec_ &TABLE%ROWTYPE;
BEGIN
   General_SYS.Init_Method(lu_name_, '&PKG', 'Remove__');
   IF (action_ = 'CHECK') THEN
      remrec_ := Get_Object_By_Id___(objid_);
      Check_Delete___(remrec_);
   ELSIF (action_ = 'DO') THEN
      remrec_ := Lock_By_Id___(objid_, objversion_);
      Check_Delete___(remrec_);
      Delete___(objid_, remrec_);
   END IF;
   info_ := Client_SYS.Get_All_Info;
END Remove__;

-----------------------------------------------------------------------------
-------------------- PUBLIC BASE METHODS ------------------------------------
-----------------------------------------------------------------------------
-- Exist
--   Checks if given pointer (e.g. primary key) to an instance of this
--   logical unit exists. If not an exception will be raised.
-----------------------------------------------------------------------------

PROCEDURE Exist (
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2 )
IS
BEGIN
   General_SYS.Init_Method(lu_name_, '&PKG', 'Exist', TRUE);
   IF (NOT Check_Exist___(company_, stock_taking_unit_id_, mesin_)) THEN
      Error_SYS.Record_Not_Exist(lu_name_);
   END IF;
END Exist;

-----------------------------------------------------------------------------
-------------------- LU SPECIFIC IMPLEMENTATION METHODS ---------------------
-----------------------------------------------------------------------------


-----------------------------------------------------------------------------
-------------------- LU SPECIFIC PRIVATE METHODS ----------------------------
-----------------------------------------------------------------------------


-----------------------------------------------------------------------------
-------------------- LU SPECIFIC PROTECTED METHODS --------------------------
-----------------------------------------------------------------------------


-----------------------------------------------------------------------------
-------------------- LU SPECIFIC PUBLIC METHODS -----------------------------
-----------------------------------------------------------------------------

FUNCTION Get_Flag_Reject (
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2 ) RETURN VARCHAR2
IS
   temp_ &TABLE..flag_reject%TYPE;
   CURSOR get_attr IS
      SELECT flag_reject
      FROM &TABLE
      WHERE company = company_
      AND   stock_taking_unit_id = stock_taking_unit_id_
      AND   mesin = mesin_;
BEGIN
   OPEN get_attr;
   FETCH get_attr INTO temp_;
   CLOSE get_attr;
   RETURN temp_;
END Get_Flag_Reject;


FUNCTION Get_Keterangan (
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2 ) RETURN VARCHAR2
IS
   temp_ &TABLE..keterangan%TYPE;
   CURSOR get_attr IS
      SELECT keterangan
      FROM &TABLE
      WHERE company = company_
      AND   stock_taking_unit_id = stock_taking_unit_id_
      AND   mesin = mesin_;
BEGIN
   OPEN get_attr;
   FETCH get_attr INTO temp_;
   CLOSE get_attr;
   RETURN temp_;
END Get_Keterangan;


FUNCTION Get (
   company_ IN VARCHAR2,
   stock_taking_unit_id_ IN VARCHAR2,
   mesin_ IN VARCHAR2 ) RETURN Public_Rec
IS
   temp_ Public_Rec;
   CURSOR get_attr IS
      SELECT flag_reject, keterangan
      FROM &TABLE
      WHERE company = company_
      AND   stock_taking_unit_id = stock_taking_unit_id_
      AND   mesin = mesin_;
BEGIN
   OPEN get_attr;
   FETCH get_attr INTO temp_;
   CLOSE get_attr;
   RETURN temp_;
END Get;


PROCEDURE Create_Update_Record(
   company_                IN VARCHAR2,
   stock_taking_unit_id_   IN VARCHAR2,
   mesin_                  IN VARCHAR2,
   flag_reject_            IN VARCHAR2,
   keterangan_             IN VARCHAR2)
IS
   attr_             VARCHAR2(2000);
   objid_            VARCHAR2(200);
   objversion_       VARCHAR2(2000);
   info_             VARCHAR2(2000);

BEGIN 
   General_SYS.Init_Method(lu_name_, '&PKG', 'Create_Update_Record');
   Get_Id_Version_By_Keys___ (objid_, objversion_, company_,stock_taking_unit_id_,mesin_);

   IF objid_ IS NULL THEN
      Client_SYS.Add_To_Attr('COMPANY', company_, attr_);
      Client_SYS.Add_To_Attr('STOCK_TAKING_UNIT_ID', stock_taking_unit_id_, attr_);
      Client_SYS.Add_To_Attr('MESIN', mesin_, attr_);      
   END IF;

   Client_SYS.Add_To_Attr('FLAG_REJECT', flag_reject_, attr_);
   Client_SYS.Add_To_Attr('KETERANGAN', keterangan_, attr_);

   IF objid_ IS NULL THEN
      New__(info_, objid_, objversion_, attr_, 'DO');
   ELSE
      Modify__(info_,objid_,objversion_,attr_,'DO');
   END IF;

END Create_Update_Record;


PROCEDURE Remove_Record(
   company_                   IN VARCHAR2,
   stock_taking_unit_id_      IN VARCHAR2,
   mesin_                     IN VARCHAR2)

IS
   objid_                   VARCHAR2(200);
   objversion_              VARCHAR2(2000);
   info_                    VARCHAR2(2000);

BEGIN
   Get_Id_Version_By_Keys___ (objid_, objversion_, company_, stock_taking_unit_id_,mesin_);
   Remove__(info_, objid_, objversion_, 'DO');

END Remove_Record;


PROCEDURE Update_Keterangan(
   company_                   IN VARCHAR2,
   stock_taking_unit_id_      IN VARCHAR2,
   mesin_                     IN VARCHAR2,
   keterangan_                IN VARCHAR2)

IS
   attr_                    VARCHAR2(2000);
   objid_                   VARCHAR2(200);
   objversion_              VARCHAR2(2000);
   info_                    VARCHAR2(2000);

BEGIN
   Get_Id_Version_By_Keys___ (objid_, objversion_, company_, stock_taking_unit_id_,mesin_);
   Client_SYS.Add_To_Attr('KETERANGAN', keterangan_, attr_);
   Modify__(info_,objid_,objversion_,attr_,'DO');

END Update_Keterangan;











-----------------------------------------------------------------------------
-------------------- FOUNDATION1 METHODS ------------------------------------
-----------------------------------------------------------------------------
-- Init
--   Dummy procedure that can be called at database startup to ensure that
--   this package is loaded into memory for performance reasons only.
-----------------------------------------------------------------------------

PROCEDURE Init
IS
BEGIN
   NULL;
END Init;


END &PKG;
/
SHOW ERROR

-----------------------------------------------------------------------------