9651c48539
Includes services and functions to create new test wafer lot. Tables included outside of git push New Tables: 1. LOT 2. LOT_EVENT 3. LOT_OPERATION 4. PRODUCT_OPERATION 5. OPERATION 6. Added PRODUCT_OPERATIONS field in TEST_WAFER_PROD table. All relational indexes and btree indexes.
616 lines
32 KiB
Plaintext
616 lines
32 KiB
Plaintext
Compile function Lot_Services(@Service, @Params)
|
|
#pragma precomp SRP_PreCompiler
|
|
|
|
Declare function TEST_WAFER_PROD_SERVICES, SRP_Datetime, Datetime, Database_Services, Lot_Services, Error_Services, RTI_CREATEGUID
|
|
Declare function SRP_Array, SRP_Json
|
|
Declare subroutine Database_Services, Btree.Extract, Lot_Services, Error_Services, Labeling_Services, SRP_Json
|
|
$insert LOGICAL
|
|
$Insert LOT_EQUATES
|
|
$Insert TEST_WAFER_PROD_EQUATES
|
|
$Insert Lot_Operation_Equates
|
|
$Insert PRODUCT_OPERATION_EQUATES
|
|
$Insert LOT_EVENT_EQUATES
|
|
|
|
Options EVENT_TYPES = 'MOVE_IN', 'MOVE_OUT', 'HOLD_ON', 'HOLD_OFF', 'REDUCE_WAFER_QTY', 'BONUS_WAFER_QTY', 'COMMENT', 'LOCATION'
|
|
Options LOT_TYPES = 'TW', 'RDS', 'WM_OUT', 'WM_IN'
|
|
|
|
GoToService
|
|
|
|
Return Response or ""
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SERVICES
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Service GenerateNewLotId(LotType)
|
|
NewLotID = ''
|
|
RightNow = Datetime()
|
|
If LotType NE '' then
|
|
ValidLotNum = False$
|
|
GeneratedLotID = ''
|
|
Begin Case
|
|
Case LotType EQ 'TW'
|
|
|
|
Loop
|
|
Until ValidLotNum EQ True$
|
|
LotPrefix = 'TW'
|
|
LotYear = SRP_Datetime('Year', RightNow)
|
|
LotMonth = SRP_Datetime('Month', RightNow)
|
|
LotDay = SRP_Datetime('Day', RightNow)
|
|
LotTime = SRP_Datetime('Time', RightNow)
|
|
|
|
GeneratedLotId = LotPrefix : LotYear : LotMonth : LotDay : LotTime
|
|
If Not(RowExists('LOT', GeneratedLotId)) then
|
|
ValidLotNum = True$
|
|
end else
|
|
ValidLotNum = False$
|
|
RightNow = Datetime()
|
|
end
|
|
Repeat
|
|
Case OTHERWISE$
|
|
//null
|
|
End Case
|
|
If GeneratedLotID NE '' AND ValidLotNum then
|
|
//Write the new lot id now so it's reserved
|
|
Database_Services('WriteDataRow', 'LOT', GeneratedLotID, '')
|
|
If RowExists('LOT', GeneratedLotID) then
|
|
NewLotID = GeneratedLotID
|
|
end
|
|
end
|
|
end
|
|
Response = NewLotID
|
|
end service
|
|
|
|
Service CreateNewTestWaferLot(LotType, ProdName, LotQty, VendorPartNo, VendorLotNo, VendorCode, Username, PrinterID)
|
|
CreatedLotNumber = ''
|
|
ErrorMessage = ''
|
|
If LotType EQ 'TW' then
|
|
If ProdName NE '' then
|
|
TWProdID = Test_Wafer_Prod_Services('GetTestWaferProdIDsByPartName', ProdName)
|
|
If TWProdID NE '' then
|
|
If DCount(TWProdID, @VM) EQ 1 then
|
|
NewLotId = Lot_Services('GenerateNewLotId', 'TW')
|
|
If NewLotId NE '' then
|
|
If RowExists('LOT', NewLotId) then
|
|
LotRec = Database_Services('ReadDataRow', 'LOT', NewLotId)
|
|
//Ensure the lot record is empty
|
|
If LotRec<LOT_TYPE$> EQ '' AND LotRec<LOT_PROD_ID$> EQ '' AND LotRec<LOT_ORIG_WAFER_QTY$> EQ '' AND LotRec<LOT_WAFER_QTY$> EQ '' then
|
|
LotRec<LOT_TYPE$> = LotType
|
|
LotRec<LOT_PROD_ID$> = TWProdID
|
|
LotRec<LOT_ORIG_WAFER_QTY$> = LotQty
|
|
LotRec<LOT_WAFER_QTY$> = LotQty
|
|
LotRec<LOT_VENDOR_PART_NO$> = VendorPartNo
|
|
LotRec<LOT_VENDOR_LOT_NO$> = VendorLotNo
|
|
LotRec<LOT_VENDOR_CODE$> = VendorCode
|
|
Database_Services('WriteDataRow', 'LOT', NewLotId, LotRec)
|
|
//Now Ensure that the written lot matches what was just written
|
|
LotRecCheck = Database_Services('ReadDataRow', 'LOT', NewLotId)
|
|
If LotRecCheck EQ LotRec then
|
|
//Lot Created successfully
|
|
CreatedLotNumber = NewLotId
|
|
If RowExists('LOT', CreatedLotNumber) then
|
|
Lot_Services('CreateInitialLotOperationRecords', CreatedLotNumber)
|
|
If Error_Services('NoError') then
|
|
//Check in at first operation
|
|
//Get Curr Operation(Should be first one in sequence)
|
|
ThisLotCurrOpId = Lot_Services('GetLotCurrOperation', CreatedLotNumber)
|
|
If ThisLotCurrOpId NE '' then
|
|
Lot_Services('MoveInLot', NewLotId, LotQty, Username)
|
|
If PrinterID NE 'WEB' then
|
|
Labeling_Services('PrintTestWaferLotLabel', CreatedLotNumber, Username, PrinterID)
|
|
end
|
|
Lot_Services('MoveOutLot', NewLotId, LotQty, Username)
|
|
Lot_Services('MoveInLot', NewLotId, LotQty, Username)
|
|
end else
|
|
//Error: Error getting current operation
|
|
end
|
|
end else
|
|
//Error: Failed to initialize lot operations
|
|
end
|
|
end
|
|
end else
|
|
//Lot attributes didn't write correctly.
|
|
end
|
|
end else
|
|
//Error: Lot already had data
|
|
end
|
|
end else
|
|
//Error creating new lot ID
|
|
end
|
|
end else
|
|
//Error getting new Lot ID
|
|
end
|
|
end else
|
|
//Ambiguous Product name, multiple results.
|
|
end
|
|
end else
|
|
//No Matching part no found
|
|
end
|
|
end else
|
|
ErrorMessage = 'Null value passed in for ProdID'
|
|
end
|
|
end else
|
|
ErrorMessage = 'Lot type was not test wafer'
|
|
end
|
|
Response = CreatedLotNumber
|
|
|
|
End Service
|
|
|
|
Service GenerateInitialLotOperationRecords(LotId)
|
|
If LotID NE '' then
|
|
if RowExists('LOT', LotId) then
|
|
LotRec = Database_Services('ReadDataRow', 'LOT', LotId)
|
|
ProdID = LotRec<LOT_PROD_ID$>
|
|
If ProdID NE '' then
|
|
//Get product operations
|
|
ThisLotOperations = Lot_Services('GetPrescribedOperationsByProdId', ProdId)
|
|
If ThisLotOperations NE '' then
|
|
for each ProdOperationKey in ThisLotOperations using @FM
|
|
OperationRec = Database_Services('ReadDataRow', 'PRODUCT_OPERATION', ProdOperationKey)
|
|
|
|
//NewOperationRecID =
|
|
Next operation
|
|
end else
|
|
//Error: No Operations returned
|
|
end
|
|
end else
|
|
//Error: Prod ID for lot is null
|
|
end
|
|
//ID will be LotNum + OperationID
|
|
//Get product operations
|
|
|
|
end else
|
|
//error: lot does not exist
|
|
end
|
|
end else
|
|
//error: null lot id
|
|
end
|
|
end service
|
|
|
|
Service GetPrescribedOperationsByProdId(ProdId, ProdType)
|
|
ProdOperationKeys = ''
|
|
If ProdId NE '' then
|
|
Begin Case
|
|
Case ProdType = 'TW'
|
|
ProdRec = Database_Services('ReadDataRow', 'TEST_WAFER_PROD', ProdId)
|
|
ProdOperationKeys = ProdRec<TEST_WAFER_PROD_PRODUCT_OPERATIONS$>
|
|
Case Otherwise$
|
|
//error, no matching prod type.
|
|
End Case
|
|
end else
|
|
//Error: ProdID was null
|
|
end
|
|
Response = ProdOperationKeys
|
|
end service
|
|
|
|
Service CreateInitialLotOperationRecords(LotId)
|
|
If LotId NE '' then
|
|
LotRec = Database_Services('ReadDataRow', 'LOT', LotId)
|
|
LotType = LotRec<LOT_TYPE$>
|
|
ProdId = LotRec<LOT_PROD_ID$>
|
|
ThisInitialProdOperations = Lot_Services('GetPrescribedOperationsByProdId', ProdId, LotType)
|
|
For each ProdOperation in ThisInitialProdOperations using @VM
|
|
|
|
ProdOperationRec = Database_Services('ReadDataRow', 'PRODUCT_OPERATION', ProdOperation)
|
|
OperationID = ProdOperationRec<PRODUCT_OPERATION_OPERATION_ID$>
|
|
OperationSequence = ProdOperationRec<PRODUCT_OPERATION_OPERATION_SEQUENCE$>
|
|
|
|
LotOperationRecID = LotId : '*' : OperationID
|
|
If Not(RowExists('LOT_OPERATION', LotOperationRecID)) then
|
|
LotOperationRec = ''
|
|
LotOperationRec<LOT_OPERATION_LOT_ID$> = LotId
|
|
LotOperationRec<LOT_OPERATION_OPERATION_ID$> = OperationID
|
|
LotOperationRec<LOT_OPERATION_OPERATION_SEQUENCE$> = OperationSequence
|
|
LotOperationRec<LOT_OPERATION_REWORK$> = False$
|
|
Database_Services('WriteDataRow', 'LOT_OPERATION', LotOperationRecId, LotOperationRec)
|
|
TestRec = Database_Services('ReadDataRow', 'LOT', LotId)
|
|
end else
|
|
//Error: Lot Operation already existed, cannot overwrite
|
|
end
|
|
|
|
Next Operation
|
|
end else
|
|
//Error: Lot ID was null
|
|
end
|
|
TestRec = Database_Services('ReadDataRow', 'LOT', LotId)
|
|
end service
|
|
|
|
//Returns a @FM delimited list of operations in sequence
|
|
Service GetLotOperationSequence(LotId)
|
|
LotOperationsInSequence = ''
|
|
If LotID NE '' then
|
|
//Get Operations
|
|
LotOperations = Xlate('LOT', LotId, LOT_LOT_OPERATIONS$, 'X')
|
|
for each LotOperation in LotOperations using @VM
|
|
ThisLotOperationSequence = Xlate('LOT_OPERATION', LotOperation, LOT_OPERATION_OPERATION_SEQUENCE$, 'X')
|
|
LotOperationsInSequence<ThisLotOperationSequence> = LotOperation
|
|
Next LotOperation
|
|
end else
|
|
//error: lot id was null
|
|
end
|
|
Response = LotOperationsInSequence
|
|
end service
|
|
|
|
//Returns a @FM delimited list of events in sequence
|
|
Service GetLotEventsInSequence(LotId)
|
|
|
|
LotEventsUnsorted = ''
|
|
LotEventsSorted = ''
|
|
LotEventsToReturn = ''
|
|
If LotID NE '' then
|
|
//Get Operations
|
|
LotEvents = Xlate('LOT', LotId, LOT_LOT_EVENTS$, 'X')
|
|
for each LotEvent in LotEvents using @VM
|
|
ThisEventSequence = XLATE('LOT_EVENT', LotEvent, LOT_EVENT_SEQUENCE$, 'X')
|
|
LotEventsToReturn<ThisEventSequence> = LotEvent
|
|
Next LotOperation
|
|
end else
|
|
//error: lot id was null
|
|
end
|
|
Response = LotEventsToReturn
|
|
end service
|
|
|
|
Service GetLotCurrOperation(LotId)
|
|
CurrOperation = ''
|
|
If LotID NE '' then
|
|
//Get them in sequence first
|
|
LotOperationsInSequence = Lot_Services('GetLotOperationSequence', LotId)
|
|
for each LotOperation in LotOperationsInSequence using @FM
|
|
ThisLotOperationStartDTM = Xlate('LOT_OPERATION', LotOperation, LOT_OPERATION_DATETIME_IN$, 'X')
|
|
ThisLotOperationEndDTM = Xlate('LOT_OPERATION', LotOperation, LOT_OPERATION_DATETIME_OUT$, 'X')
|
|
If ThisLotOperationEndDTM Eq '' then
|
|
CurrOperation = LotOperation
|
|
end
|
|
until CurrOperation
|
|
Next LotOperation
|
|
end else
|
|
//error: lot id was null
|
|
end
|
|
Response = CurrOperation
|
|
end service
|
|
|
|
Service AddLotOperationIntoSequence(LotId, NewOperationId, NewSequence, Rework)
|
|
ErrorMessage = ''
|
|
If LotId NE '' then
|
|
If NewSequence NE '' AND Num(NewSequence) then
|
|
//Get Current Operations in sequence
|
|
//CurrSequence = Lot_Services('GetLotOperationSequence', LotId)
|
|
LotCurrOperation = Lot_Services('GetLotCurrOperation', LotId)
|
|
CurrOperationSequence = Xlate('LOT_OPERATION', LotCurrOperation, LOT_OPERATION_OPERATION_SEQUENCE$, 'X')
|
|
If CurrOperationSequence LE NewSequence then
|
|
//Get Curr Operation Sequence
|
|
Done = False$
|
|
LotCurrOperationSequence = Lot_Services('GetLotOperationSequence', LotId)
|
|
for each Operation in LotCurrOperationSequence using @Fm setting OpPos
|
|
ThisOperationRec = Database_Services('ReadDataRow', 'LOT_OPERATION', Operation)
|
|
ThisOperationSequence = ThisOperationRec<LOT_OPERATION_OPERATION_SEQUENCE$>
|
|
If ThisOperationSequence GE NewSequence then
|
|
NewOperationSequence = ThisOperationSequence + 1
|
|
ThisOperationRec<LOT_OPERATION_OPERATION_SEQUENCE$> = NewOperationSequence
|
|
Database_Services('WriteDataRow', 'LOT_OPERATION', Operation, ThisOperationRec)
|
|
If Error_Services('HasError') then
|
|
Done = True$
|
|
ErrorMessage = Error_Services('GetMessage')
|
|
end
|
|
end
|
|
Until Done
|
|
Next Operation
|
|
If ErrorMessage EQ '' then
|
|
LotOperationRecID = LotId : '*' : NewOperationId
|
|
If Not(RowExists('LOT_OPERATION', LotOperationRecID)) then
|
|
LotOperationRec = ''
|
|
LotOperationRec<LOT_OPERATION_LOT_ID$> = LotId
|
|
LotOperationRec<LOT_OPERATION_OPERATION_ID$> = NewOperationId
|
|
LotOperationRec<LOT_OPERATION_OPERATION_SEQUENCE$> = NewSequence
|
|
LotOperationRec<LOT_OPERATION_REWORK$> = Rework
|
|
Database_Services('WriteDataRow', 'LOT_OPERATION', LotOperationRecId, LotOperationRec)
|
|
end else
|
|
//Error: Lot Operation already existed, cannot overwrite
|
|
end
|
|
end
|
|
end else
|
|
//Error: Not allowed to add new operations prior to current operation
|
|
end
|
|
end else
|
|
//Error: null or invalid sequence passed to routine
|
|
end
|
|
end else
|
|
//Error: Lot id was null
|
|
end
|
|
If ErrorMessage NE '' then
|
|
Error_Services('Add', ErrorMessage)
|
|
end
|
|
end service
|
|
|
|
Service MoveInLot(LotID, WaferQty, Operator)
|
|
If LotId NE '' then
|
|
If WaferQty NE '' then
|
|
If RowExists('LOT', LotId) then
|
|
ThisLotRec = Database_Services('ReadDataRow', 'LOT', LotId)
|
|
//Possibly Add locking here
|
|
If Error_Services('NoError') then
|
|
ThisLotCurrOperationID = Lot_Services('GetLotCurrOperation', LotId)
|
|
If ThisLotCurrOperationID NE '' then
|
|
ThisLotCurrOperationRec = Database_Services('ReadDataRow', 'LOT_OPERATION', ThisLotCurrOperationID)
|
|
ThisLotCurrOperationRec<LOT_OPERATION_DATETIME_IN$> = Datetime()
|
|
ThisLotCurrOperationRec<LOT_OPERATION_WAFER_IN_QTY$> = WaferQty
|
|
ThisLotCurrOperationRec<LOT_OPERATION_OPERATOR_IN_ID$> = Operator
|
|
Database_Services('WriteDataRow', 'LOT_OPERATION', ThisLotCurrOperationID, ThisLotCurrOperationRec)
|
|
If Error_Services('NoError') then
|
|
LotType = XLATE('LOT', LotId, LOT_TYPE$, 'X')
|
|
CurrOperation = XLATE('LOT_OPERATION', ThisLotCurrOperationID, LOT_OPERATION_OPERATION_ID$, 'X')
|
|
Lot_Services('CreateLotEvent', LotId, LotType, Datetime(), 'MOVE_IN', '', '', 0, 0, CurrOperation, Operator)
|
|
end
|
|
end
|
|
|
|
//Log to Lot Event Table
|
|
end else
|
|
//Error: Error reading record
|
|
end
|
|
|
|
end else
|
|
//Error Invalid Lot id entered
|
|
end
|
|
end else
|
|
//Error: Wafer Qty was null
|
|
end
|
|
end else
|
|
//Error: Lot Id was null
|
|
end
|
|
end service
|
|
|
|
Service MoveOutLot(LotID, WaferQty, Operator)
|
|
If LotId NE '' then
|
|
If WaferQty NE '' then
|
|
If RowExists('LOT', LotId) then
|
|
ThisLotRec = Database_Services('ReadDataRow', 'LOT', LotId)
|
|
CurrLotQty = ThisLotRec<LOT_WAFER_QTY$>
|
|
BonusQty = 0
|
|
ReduceQty = 0
|
|
If WaferQty NE CurrLotQty then
|
|
Begin Case
|
|
Case WaferQty GT CurrLotQty
|
|
//Addition of wafers
|
|
BonusQty = WaferQty - CurrLotQty
|
|
Case WaferQty LT CurrLotQty
|
|
ReduceQty = CurrLotQty - WaferQty
|
|
End Case
|
|
end
|
|
//Possibly Add locking here
|
|
If Error_Services('NoError') then
|
|
ThisLotCurrOperationID = Lot_Services('GetLotCurrOperation', LotId)
|
|
If ThisLotCurrOperationID NE '' then
|
|
ThisLotCurrOperationRec = Database_Services('ReadDataRow', 'LOT_OPERATION', ThisLotCurrOperationID)
|
|
ThisLotCurrOperationRec<LOT_OPERATION_DATETIME_OUT$> = Datetime()
|
|
ThisLotCurrOperationRec<LOT_OPERATION_WAFER_OUT_QTY$> = WaferQty
|
|
ThisLotCurrOperationRec<LOT_OPERATION_OPERATOR_OUT_ID$> = Operator
|
|
Database_Services('WriteDataRow', 'LOT_OPERATION', ThisLotCurrOperationID, ThisLotCurrOperationRec)
|
|
If Error_Services('NoError') then
|
|
LotType = XLATE('LOT', LotId, LOT_TYPE$, 'X')
|
|
|
|
CurrOperation = XLATE('LOT_OPERATION', ThisLotCurrOperationID, LOT_OPERATION_OPERATION_ID$, 'X')
|
|
Lot_Services('CreateLotEvent', LotId, LotType, Datetime(), 'MOVE_OUT', '', '', ReduceQty, BonusQty, CurrOperation, Operator)
|
|
end
|
|
end
|
|
//Log to lot event table.
|
|
end else
|
|
//Error: Error reading record
|
|
end
|
|
|
|
end else
|
|
//Error Invalid Lot id entered
|
|
end
|
|
end else
|
|
//Error: Wafer Qty was null
|
|
end
|
|
end else
|
|
//Error: Lot Id was null
|
|
end
|
|
end service
|
|
|
|
Service CreateLotEvent(LotId, LotType=LOT_TYPES, EventDatetime, EventType=EVENT_TYPES, EventNote, EventEquipmentId, ReduceWaferQty, BonusWaferQty, OperationId, OperatorId)
|
|
If LotId NE '' then
|
|
Begin Case
|
|
Case LotType EQ 'TW'
|
|
If EventType NE '' AND OperatorId NE '' then
|
|
If RowExists('LOT', LotId) then
|
|
ValidId = False$
|
|
NewEventId = ''
|
|
Loop
|
|
NewEventId = RTI_CreateGUID()
|
|
If Not(RowExists('LOT_EVENT', NewEventId)) then
|
|
ValidId = True$
|
|
end
|
|
Until ValidId EQ True$
|
|
Repeat
|
|
BeginWaferQty = Xlate('LOT', LotId, LOT_WAFER_QTY$, 'X')
|
|
If OperationID EQ '' then
|
|
OperationID = Lot_Services('GetLotCurrOperation', LotId)
|
|
OperationID = XLATE('LOT_OPERATION', OperationID, LOT_OPERATION_OPERATION_ID$, 'X')
|
|
end
|
|
If ReduceWaferQty NE '' then
|
|
If Num(ReduceWaferQty) then
|
|
EndWaferQty = BeginWaferQty - ReduceWaferQty
|
|
end
|
|
end
|
|
If BonusWaferQty NE '' then
|
|
If Num(BonusWaferQty) then
|
|
EndWaferQty = BeginWaferQty + BonusWaferQty
|
|
end
|
|
end
|
|
NewEventRec = ''
|
|
NewEventRec<LOT_EVENT_LOT_ID$> = LotId
|
|
NewEventRec<LOT_EVENT_LOT_EVENT_TYPE$> = EventType
|
|
NewEventRec<LOT_EVENT_EVENT_DATETIME$> = EventDatetime
|
|
NewEventRec<LOT_EVENT_EVENT_NOTE$> = EventNote
|
|
NewEventRec<LOT_EVENT_EQUIPMENT_ID$> = EventEquipmentId
|
|
NewEventRec<LOT_EVENT_EVENT_REDUCE_WAFER_QTY$> = ReduceWaferQty
|
|
NewEventRec<LOT_EVENT_EVENT_BONUS_WAFER_QTY$> = BonusWaferQty
|
|
NewEventRec<LOT_EVENT_EVENT_BEGIN_WAFER_QTY$> = BeginWaferQty
|
|
NewEventRec<LOT_EVENT_EVENT_END_WAFER_QTY$> = EndWaferQty
|
|
NewEventRec<LOT_EVENT_EVENT_OPERATION_ID$> = OperationId
|
|
NewEventRec<LOT_EVENT_EVENT_OPERATOR_ID$> = OperatorId
|
|
|
|
NewEventSequence = Lot_Services('GetLotEventNextSequence', LotId)
|
|
NewEventRec<LOT_EVENT_SEQUENCE$> = NewEventSequence
|
|
Database_Services('WriteDataRow', 'LOT_EVENT', NewEventId, NewEventRec)
|
|
end else
|
|
//Error: Nonexistent Lot Id passed to routine
|
|
end
|
|
end else
|
|
//Error Missing Parameter
|
|
end
|
|
Case LotType EQ 'RDS'
|
|
null
|
|
Case LotType EQ 'WM_OUT'
|
|
null
|
|
Case LotType EQ 'WM_IN'
|
|
null
|
|
Case Otherwise$
|
|
//Error: Invalid LotType Passed to routine
|
|
End Case
|
|
end else
|
|
//Error: Lot ID was null
|
|
end
|
|
end service
|
|
|
|
Service GetLotEventNextSequence(LotId)
|
|
ErrorMessage = ''
|
|
NextSequence = 1
|
|
If LotID NE '' then
|
|
If RowExists('LOT', LotId) then
|
|
LotEvents = XLATE('LOT', LotId, LOT_LOT_EVENTS$, 'X')
|
|
for each LotEvent in LotEvents using @VM
|
|
ThisEventSequence = XLATE('LOT_EVENT', LotEvent, LOT_EVENT_SEQUENCE$, 'X')
|
|
If ThisEventSequence GE NextSequence then NextSequence = ThisEventSequence + 1
|
|
Next LotEvent
|
|
end else
|
|
ErrorMessage = 'Unable to get lot event sequence: Lot ID not found.'
|
|
end
|
|
end else
|
|
ErrorMessage = 'Unable to get lot event sequence: Lot ID was null.'
|
|
end
|
|
If ErrorMessage EQ '' then
|
|
Response = NextSequence
|
|
end else
|
|
Error_Services('Add', ErrorMessage)
|
|
end
|
|
end service
|
|
|
|
Service ConvertLotRecordToJson(LotId, ItemURL, CurrUser, FullObject=BOOLEAN)
|
|
|
|
ErrorMessage = ''
|
|
JsonString = ''
|
|
If FullObject EQ '' then
|
|
FullObject = True$
|
|
end
|
|
If RowExists('LOT', LotId) then
|
|
objJSON = ''
|
|
If SRP_JSON(objJSON, 'New', 'Object') then
|
|
LotRec = Database_Services('ReadDataRow', 'LOT', LotId)
|
|
If Error_Services('NoError') then
|
|
If SRP_JSON(objLot, 'New', 'Object') then
|
|
|
|
SRP_JSON(objLot, 'SetValue', 'LotId', LotId)
|
|
SRP_JSON(objLot, 'SetValue', 'Type', LotRec<LOT_TYPE$>)
|
|
SRP_JSON(objLot, 'SetValue', 'ProdId', LotRec<LOT_PROD_ID$>)
|
|
Begin Case
|
|
Case LotRec<LOT_TYPE$> = 'TW'
|
|
ProdName = XLATE('TEST_WAFER_PROD', LotRec<LOT_PROD_ID$>, TEST_WAFER_PROD_PART_NAME$, 'X')
|
|
Case Otherwise$
|
|
ProdName = ''
|
|
End Case
|
|
SRP_JSON(objLot, 'SetValue', 'ProdName', ProdName)
|
|
SRP_JSON(objLot, 'SetValue', 'OrigWaferQty', LotRec<LOT_ORIG_WAFER_QTY$>)
|
|
SRP_JSON(objLot, 'SetValue', 'WaferQty', LotRec<LOT_WAFER_QTY$>)
|
|
SRP_JSON(objLot, 'SetValue', 'VendorPartNo', LotRec<LOT_VENDOR_PART_NO$>)
|
|
SRP_JSON(objLot, 'SetValue', 'VendorLotNo', LotRec<LOT_VENDOR_LOT_NO$>)
|
|
If FullObject then
|
|
//Events Array
|
|
EventsArrayJson = ''
|
|
If SRP_Json(EventsArrayJson, 'New', 'Array') then
|
|
LotEventKeys = Lot_Services('GetLotEventsInSequence', LotId)
|
|
for each LotEventKey in LotEventKeys using @FM
|
|
objEvent = ''
|
|
EventRec = Database_Services('ReadDataRow', 'LOT_EVENT', LotEventKey)
|
|
If SRP_Json(objEvent, 'New', 'Object') then
|
|
SRP_JSON(objEvent, 'SetValue', 'LotEventId', LotEventKey)
|
|
SRP_JSON(objEvent, 'SetValue', 'LotId', EventRec<LOT_EVENT_LOT_ID$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'LotEventType', EventRec<LOT_EVENT_LOT_EVENT_TYPE$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EventDatetime', OConv(EventRec<LOT_EVENT_EVENT_DATETIME$>, 'DT'))
|
|
SRP_JSON(objEvent, 'SetValue', 'EventNote', EventRec<LOT_EVENT_EVENT_NOTE$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EquipmentId', EventRec<LOT_EVENT_EQUIPMENT_ID$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EventReduceWaferQty', EventRec<LOT_EVENT_EVENT_REDUCE_WAFER_QTY$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EventBonusWaferQty', EventRec<LOT_EVENT_EVENT_BONUS_WAFER_QTY$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EventBeginWaferQty', EventRec<LOT_EVENT_EVENT_BEGIN_WAFER_QTY$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EventEndWaferQty', EventRec<LOT_EVENT_EVENT_END_WAFER_QTY$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EventOperationId', EventRec<LOT_EVENT_EVENT_OPERATION_ID$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'EventOperatorId', EventRec<LOT_EVENT_EVENT_OPERATOR_ID$>)
|
|
SRP_JSON(objEvent, 'SetValue', 'Sequence', EventRec<LOT_EVENT_SEQUENCE$>)
|
|
SRP_JSON(EventsArrayJson, 'Add', objEvent)
|
|
SRP_JSON(objEvent, 'Release')
|
|
end
|
|
Next LotEventKey
|
|
SRP_JSON(objLot, 'Set', 'LotEvents', EventsArrayJson)
|
|
SRP_JSON(EventsArrayJson, 'Release')
|
|
end else
|
|
ErrorMessage = 'Error Creating Events JSON Array'
|
|
end
|
|
//Operations Array
|
|
OperationsArrayJson = ''
|
|
If SRP_Json(OperationsArrayJson, 'New', 'Array') then
|
|
LotOperationKeys = Lot_Services('GetLotOperationSequence', LotId)
|
|
for each LotOperationKey in LotOperationKeys using @FM
|
|
objOperation = ''
|
|
OperationRec = Database_Services('ReadDataRow', 'LOT_OPERATION', LotOperationKey)
|
|
If SRP_Json(objOperation, 'New', 'Object') then
|
|
SRP_JSON(objOperation, 'SetValue', 'LotOperationId', LotOperationKey)
|
|
SRP_JSON(objOperation, 'SetValue', 'LotId', OperationRec<LOT_OPERATION_LOT_ID$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'OperationId', OperationRec<LOT_OPERATION_OPERATION_ID$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'DatetimeIn', OConv(OperationRec<LOT_OPERATION_DATETIME_IN$>, 'DT'))
|
|
SRP_JSON(objOperation, 'SetValue', 'DatetimeOut', Oconv(OperationRec<LOT_OPERATION_DATETIME_OUT$>, 'DT'))
|
|
SRP_JSON(objOperation, 'SetValue', 'EquipmentId', OperationRec<LOT_OPERATION_EQUIPMENT_ID$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'WaferInQty', OperationRec<LOT_OPERATION_WAFER_IN_QTY$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'WaferOutQty', OperationRec<LOT_OPERATION_WAFER_OUT_QTY$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'OperatorInId', OperationRec<LOT_OPERATION_OPERATOR_IN_ID$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'OperatorOutId', OperationRec<LOT_OPERATION_OPERATOR_OUT_ID$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'OperationSequence', OperationRec<LOT_OPERATION_OPERATION_SEQUENCE$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'Rework', OperationRec<LOT_OPERATION_REWORK$>)
|
|
SRP_JSON(objOperation, 'SetValue', 'DatetimeStart', OConv(OperationRec<LOT_OPERATION_DATETIME_START$>, 'DT'))
|
|
SRP_JSON(objOperation, 'SetValue', 'DatetimeStop', OConv(OperationRec<LOT_OPERATION_DATETIME_STOP$>, 'DT'))
|
|
SRP_JSON(OperationsArrayJson, 'Add', objOperation)
|
|
SRP_JSON(objOperation, 'Release')
|
|
end
|
|
|
|
Next LotOperationKey
|
|
SRP_JSON(objLot, 'Set', 'LotOperations', OperationsArrayJson)
|
|
SRP_JSON(OperationsArrayJson, 'Release')
|
|
end else
|
|
ErrorMessage = 'Error Creating Operations JSON Array'
|
|
end
|
|
end
|
|
|
|
SRP_JSON(objJSON, 'Set', 'Lot', objLot)
|
|
SRP_JSON(objLot, 'Release')
|
|
end else
|
|
ErrorMessage = 'Error creating new Lot Json Object'
|
|
end
|
|
end else
|
|
ErrorMessage = 'Error reading ':LotId:' from lot table.'
|
|
end
|
|
JsonString = SRP_JSON(objJSON, 'Stringify', 'Styled')
|
|
SRP_JSON(objJSON, 'Release')
|
|
end else
|
|
ErrorMessage = 'Error creating new Json Object'
|
|
end
|
|
end else
|
|
ErrorMessage = 'Invalid or null lot number passed to routine.'
|
|
end
|
|
If ErrorMessage NE '' then
|
|
Error_Services('Add', ErrorMessage)
|
|
end
|
|
Response = JsonString
|
|
end service
|
|
|
|
|