APPS.WIP_AUTOLOTPROC_PRIV dependencies on WIP_LOGGER

Line 130: l_params wip_logger.param_tbl_t;

126: l_curItem system.wip_component_obj_t;
127: l_treeID NUMBER;
128: l_prevItem NUMBER := -1;
129: l_lotTbl system.wip_txn_lot_tbl_t;
130: l_params wip_logger.param_tbl_t;
131: l_errMsg VARCHAR2(80);
132: l_entryType NUMBER;
133: l_logLevel NUMBER := to_number(fnd_log.g_current_runtime_level);
134: begin

Line 141: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',

137: l_params(1).paramName := 'p_orgID';
138: l_params(1).paramValue := p_orgID;
139: l_params(2).paramName := 'p_wipEntityID';
140: l_params(2).paramValue := p_wipEntityID;
141: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',
142: p_params => l_params,
143: x_returnStatus => x_returnStatus);
144: end if;
145:

Line 214: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',

210: l_treeID := null;
211: end if;
212:
213: if (l_logLevel <= wip_constants.trace_logging) then
214: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',
215: p_procReturnStatus => x_returnStatus,
216: p_msg => 'procedure success',
217: x_returnStatus => l_returnStatus); --discard logging return status
218: end if;

Line 220: wip_logger.cleanup(x_returnStatus => l_returnStatus);

216: p_msg => 'procedure success',
217: x_returnStatus => l_returnStatus); --discard logging return status
218: end if;
219: if(fnd_api.to_boolean(p_endDebug)) then
220: wip_logger.cleanup(x_returnStatus => l_returnStatus);
221: end if;
222: exception
223: when fnd_api.g_exc_unexpected_error then
224: x_returnStatus := fnd_api.g_ret_sts_unexp_error;

Line 226: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',

222: exception
223: when fnd_api.g_exc_unexpected_error then
224: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
225: if (l_logLevel <= wip_constants.trace_logging) then
226: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',
227: p_procReturnStatus => x_returnStatus,
228: p_msg => l_errMsg,
229: x_returnStatus => l_returnStatus); --discard logging return status
230: end if;

Line 232: wip_logger.cleanup(x_returnStatus => l_returnStatus);

228: p_msg => l_errMsg,
229: x_returnStatus => l_returnStatus); --discard logging return status
230: end if;
231: if(fnd_api.to_boolean(p_endDebug)) then
232: wip_logger.cleanup(x_returnStatus => l_returnStatus);
233: end if;
234: when others then
235: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
236: if (l_logLevel <= wip_constants.trace_logging) then

Line 237: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',

233: end if;
234: when others then
235: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
236: if (l_logLevel <= wip_constants.trace_logging) then
237: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLots',
238: p_procReturnStatus => x_returnStatus,
239: p_msg => 'unexpected error:' || SQLERRM,
240: x_returnStatus => l_returnStatus); --discard logging return status
241: end if;

Line 246: wip_logger.cleanup(x_returnStatus => l_returnStatus);

242: fnd_msg_pub.add_exc_msg(p_pkg_name => 'wip_autoLotProc_priv',
243: p_procedure_name => 'deriveLots',
244: p_error_text => SQLERRM);
245: if(fnd_api.to_boolean(p_endDebug)) then
246: wip_logger.cleanup(x_returnStatus => l_returnStatus);
247: end if;
248: end deriveLots;
249: /*
250: procedure deriveLotsFromMMTT(p_orgID IN NUMBER,

Line 267: l_params wip_logger.param_tbl_t;

263: l_lotReturnStatus VARCHAR2(1);
264: l_serialReturnStatus VARCHAR2(1);
265: l_tempReturnStatus VARCHAR2(1);
266: l_errMsg VARCHAR2(80);
267: l_params wip_logger.param_tbl_t;
268: l_returnStatus VARCHAR2(1);
269: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
270: cursor c_cplItems return itemInfo_rec_t is
271: select mmtt.transaction_temp_id,

Line 368: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',

364: l_params(3).paramName := 'p_orgID';
365: l_params(3).paramValue := p_orgID;
366: l_params(4).paramName := 'p_wipEntityID';
367: l_params(4).paramValue := p_wipEntityID;
368: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',
369: p_params => l_params,
370: x_returnStatus => x_returnStatus);
371: end if;
372:

Line 400: wip_logger.log('priQty:' || l_itemRec.priQty || '; lot quantity:' || l_itemRec.lotPriQty, l_returnStatus);

396: end if;
397: end if;
398:
399: if (l_logLevel <= wip_constants.full_logging) then
400: wip_logger.log('priQty:' || l_itemRec.priQty || '; lot quantity:' || l_itemRec.lotPriQty, l_returnStatus);
401: end if;
402: if(abs(l_itemRec.priQty) > nvl(l_itemRec.lotPriQty, 0)) then
403: if (l_logLevel <= wip_constants.full_logging) then
404: wip_logger.log('at item ' || l_itemRec.itemName,l_returnStatus);

Line 404: wip_logger.log('at item ' || l_itemRec.itemName,l_returnStatus);

400: wip_logger.log('priQty:' || l_itemRec.priQty || '; lot quantity:' || l_itemRec.lotPriQty, l_returnStatus);
401: end if;
402: if(abs(l_itemRec.priQty) > nvl(l_itemRec.lotPriQty, 0)) then
403: if (l_logLevel <= wip_constants.full_logging) then
404: wip_logger.log('at item ' || l_itemRec.itemName,l_returnStatus);
405: end if;
406: if(l_itemRec.lotControlCode = wip_constants.lot) then
407: if (l_logLevel <= wip_constants.full_logging) then
408: wip_logger.log('adding item ' || l_itemRec.itemName || ';' || l_itemRec.itemID, l_returnStatus);

Line 408: wip_logger.log('adding item ' || l_itemRec.itemName || ';' || l_itemRec.itemID, l_returnStatus);

404: wip_logger.log('at item ' || l_itemRec.itemName,l_returnStatus);
405: end if;
406: if(l_itemRec.lotControlCode = wip_constants.lot) then
407: if (l_logLevel <= wip_constants.full_logging) then
408: wip_logger.log('adding item ' || l_itemRec.itemName || ';' || l_itemRec.itemID, l_returnStatus);
409: end if;
410: l_compObj.addItem(p_opSeqNum => l_itemRec.opSeqNum,
411: p_itemID => l_itemRec.itemID,
412: p_itemName => l_itemRec.itemName,

Line 489: wip_logger.log('start outer loop for item' || l_itemRec.itemID, l_returnStatus);

485: end if;
486: end if;
487:
488: if (l_logLevel <= wip_constants.full_logging) then
489: wip_logger.log('start outer loop for item' || l_itemRec.itemID, l_returnStatus);
490: end if;
491:
492: if(l_itemRec.lotControlCode <> wip_constants.lot) then
493: goto START_OF_OUTER_LOOP; --skip this item if it's not lot controlled

Line 498: wip_logger.log('start inner loop1',l_returnStatus);

494: end if;
495:
496: loop
497: if (l_logLevel <= wip_constants.full_logging) then
498: wip_logger.log('start inner loop1',l_returnStatus);
499: end if;
500: if(l_compObj.setNextItem) then
501: if(not l_compObj.getCurrentItem(l_item)) then
502: l_errMsg := 'object error';

Line 506: wip_logger.log('found item: ' || l_item.inventory_item_id, l_returnStatus);

502: l_errMsg := 'object error';
503: raise fnd_api.g_exc_unexpected_error;
504: end if;
505: if (l_logLevel <= wip_constants.full_logging) then
506: wip_logger.log('found item: ' || l_item.inventory_item_id, l_returnStatus);
507: end if;
508:
509: if(l_item.inventory_item_id = l_itemRec.itemID and
510: l_item.supply_subinventory = l_itemRec.supplySubinv and

Line 515: wip_logger.log('item: ' || l_item.inventory_item_id || ' matches cursor item', l_returnStatus);

511: nvl(l_item.supply_locator_id, -1) = nvl(l_itemRec.supplyLocID, -1) and
512: l_item.operation_seq_num = l_itemRec.opSeqNum and
513: l_item.primary_quantity = l_itemRec.priQty) then
514: if (l_logLevel <= wip_constants.full_logging) then
515: wip_logger.log('item: ' || l_item.inventory_item_id || ' matches cursor item', l_returnStatus);
516: end if;
517: exit; --found an item to match the cursor
518: end if;
519: else

Line 521: wip_logger.log('ran out of items', l_returnStatus);

517: exit; --found an item to match the cursor
518: end if;
519: else
520: if (l_logLevel <= wip_constants.full_logging) then
521: wip_logger.log('ran out of items', l_returnStatus);
522: end if;
523: goto END_OF_OUTER_LOOP; --must exit inner and outer loop!
524: end if;
525: end loop;

Line 530: wip_logger.log('start inner loop2', l_returnStatus);

526:
527:
528: while(l_compObj.getNextLot(l_lot)) loop
529: if (l_logLevel <= wip_constants.full_logging) then
530: wip_logger.log('start inner loop2', l_returnStatus);
531: end if;
532: insert into mtl_transaction_lots_temp
533: (transaction_temp_id,
534: last_update_date,

Line 563: wip_logger.log('end outer loop', l_returnStatus);

559: abs(round(l_lot.primary_quantity, wip_constants.inv_max_precision)),
560: l_lot.lot_number);
561: end loop;
562: if (l_logLevel <= wip_constants.full_logging) then
563: wip_logger.log('end outer loop', l_returnStatus);
564: end if;
565: end loop;
566: <>
567: if(c_cplItems%ISOPEN) then

Line 575: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',

571: end if;
572:
573: --return status has already been set at this point
574: if (l_logLevel <= wip_constants.trace_logging) then
575: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',
576: p_procReturnStatus => x_returnStatus,
577: p_msg => 'procedure success',
578: x_returnStatus => l_returnStatus); --discard logging return status
579: end if;

Line 581: wip_logger.cleanup(x_returnStatus => l_returnStatus);

577: p_msg => 'procedure success',
578: x_returnStatus => l_returnStatus); --discard logging return status
579: end if;
580: if(fnd_api.to_boolean(p_endDebug)) then
581: wip_logger.cleanup(x_returnStatus => l_returnStatus);
582: end if;
583: exception
584: when fnd_api.g_exc_unexpected_error then
585: x_returnStatus := fnd_api.g_ret_sts_unexp_error;

Line 588: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',

584: when fnd_api.g_exc_unexpected_error then
585: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
586: rollback to wiplotpb_10;
587: if (l_logLevel <= wip_constants.trace_logging) then
588: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',
589: p_procReturnStatus => x_returnStatus,
590: p_msg => l_errMsg,
591: x_returnStatus => l_returnStatus); --discard logging return status
592: end if;

Line 594: wip_logger.cleanup(x_returnStatus => l_returnStatus);

590: p_msg => l_errMsg,
591: x_returnStatus => l_returnStatus); --discard logging return status
592: end if;
593: if(fnd_api.to_boolean(p_endDebug)) then
594: wip_logger.cleanup(x_returnStatus => l_returnStatus);
595: end if;
596: when others then
597: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
598: rollback to wiplotpb_10;

Line 603: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',

599: fnd_msg_pub.add_exc_msg(p_pkg_name => 'wip_autoLotProc_priv',
600: p_procedure_name => 'deriveLotsFromMMTT',
601: p_error_text => SQLERRM);
602: if (l_logLevel <= wip_constants.trace_logging) then
603: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMMTT',
604: p_procReturnStatus => x_returnStatus,
605: p_msg => 'unexpected error:' || SQLERRM,
606: x_returnStatus => l_returnStatus); --discard logging return status
607: end if;

Line 609: wip_logger.cleanup(x_returnStatus => l_returnStatus);

605: p_msg => 'unexpected error:' || SQLERRM,
606: x_returnStatus => l_returnStatus); --discard logging return status
607: end if;
608: if(fnd_api.to_boolean(p_endDebug)) then
609: wip_logger.cleanup(x_returnStatus => l_returnStatus);
610: end if;
611: end deriveLotsFromMMTT;
612: */
613:

Line 632: l_params wip_logger.param_tbl_t;

628: l_lotReturnStatus VARCHAR2(1);
629: l_serialReturnStatus VARCHAR2(1);
630: l_tempReturnStatus VARCHAR2(1);
631: l_errMsg VARCHAR2(80);
632: l_params wip_logger.param_tbl_t;
633: l_returnStatus VARCHAR2(1);
634: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
635: l_itemRecTbl itemInfo_recTbl_t;
636: l_supType NUMBER;

Line 792: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',

788: l_params(4).paramName := 'p_orgID';
789: l_params(4).paramValue := p_orgID;
790: l_params(5).paramName := 'p_wipEntityID';
791: l_params(5).paramValue := p_wipEntityID;
792: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',
793: p_params => l_params,
794: x_returnStatus => x_returnStatus);
795: end if;
796:

Line 855: wip_logger.log('priQty:' || l_itemRecTbl.priQty(i) || '; lot quantity:' || l_itemRecTbl.lotPriQty(i), l_returnStatus);

851:
852: for i in 1..l_itemRecTbl.itemID.count loop
853: <>
854: if (l_logLevel <= wip_constants.full_logging) then
855: wip_logger.log('priQty:' || l_itemRecTbl.priQty(i) || '; lot quantity:' || l_itemRecTbl.lotPriQty(i), l_returnStatus);
856: end if;
857:
858: if(abs(l_itemRecTbl.priQty(i)) > abs(nvl(l_itemRecTbl.lotPriQty(i), 0))) then
859: if (l_logLevel <= wip_constants.full_logging) then

Line 860: wip_logger.log('adding item ' || l_itemRecTbl.itemName(i) || ';' || l_itemRecTbl.itemID(i), l_returnStatus);

856: end if;
857:
858: if(abs(l_itemRecTbl.priQty(i)) > abs(nvl(l_itemRecTbl.lotPriQty(i), 0))) then
859: if (l_logLevel <= wip_constants.full_logging) then
860: wip_logger.log('adding item ' || l_itemRecTbl.itemName(i) || ';' || l_itemRecTbl.itemID(i), l_returnStatus);
861: end if;
862:
863: if(l_itemRecTbl.lotControlCode(i) = wip_constants.lot) then
864: if(l_itemRecTbl.movTxnID(i) is not null) then

Line 931: wip_logger.log('start outer loop for item' || l_itemRecTbl.itemID(i), l_returnStatus);

927: l_compObj.reset;
928: --2nd pass: update all the mti rows with lot info
929: for i in 1..l_itemRecTbl.txnID.count loop
930: if (l_logLevel <= wip_constants.full_logging) then
931: wip_logger.log('start outer loop for item' || l_itemRecTbl.itemID(i), l_returnStatus);
932: end if;
933:
934: if(l_itemRecTbl.lotControlCode(i) <> wip_constants.lot) then
935: goto END_OF_OUTER_LOOP;

Line 940: wip_logger.log('start inner loop1', l_returnStatus);

936: end if;
937:
938: loop
939: if (l_logLevel <= wip_constants.full_logging) then
940: wip_logger.log('start inner loop1', l_returnStatus);
941: end if;
942: if(l_compObj.setNextItem) then
943: if(not l_compObj.getCurrentItem(l_item)) then
944: l_errMsg := 'object error';

Line 948: wip_logger.log('found item: ' || l_item.inventory_item_id, l_returnStatus);

944: l_errMsg := 'object error';
945: raise fnd_api.g_exc_unexpected_error;
946: end if;
947: if (l_logLevel <= wip_constants.full_logging) then
948: wip_logger.log('found item: ' || l_item.inventory_item_id, l_returnStatus);
949: end if;
950:
951: if(l_item.inventory_item_id = l_itemRecTbl.itemID(i) and
952: l_item.supply_subinventory = l_itemRecTbl.supplySubinv(i) and

Line 957: wip_logger.log('item: ' || l_item.inventory_item_id || ' matches cursor item', l_returnStatus);

953: nvl(l_item.supply_locator_id, -1) = nvl(l_itemRecTbl.supplyLocID(i), -1) and
954: l_item.operation_seq_num = l_itemRecTbl.opSeqNum(i) and
955: l_item.primary_quantity = l_itemRecTbl.priQty(i)) then
956: if (l_logLevel <= wip_constants.full_logging) then
957: wip_logger.log('item: ' || l_item.inventory_item_id || ' matches cursor item', l_returnStatus);
958: end if;
959: exit; --found an item to match the cursor
960: end if;
961: else

Line 963: wip_logger.log('ran out of items', l_returnStatus);

959: exit; --found an item to match the cursor
960: end if;
961: else
962: if (l_logLevel <= wip_constants.full_logging) then
963: wip_logger.log('ran out of items', l_returnStatus);
964: end if;
965: goto END_OF_OUTER_LOOP; --must exit inner and outer loop!
966: end if;
967: end loop;

Line 972: wip_logger.log('start inner loop2', l_returnStatus);

968:
969:
970: while(l_compObj.getNextLot(l_lot)) loop
971: if (l_logLevel <= wip_constants.full_logging) then
972: wip_logger.log('start inner loop2', l_returnStatus);
973: end if;
974: insert into mtl_transaction_lots_interface
975: (transaction_interface_id,
976: last_update_date,

Line 1006: wip_logger.log('end outer loop', l_returnStatus);

1002: l_lot.lot_number);
1003: end loop;
1004: <>
1005: if (l_logLevel <= wip_constants.full_logging) then
1006: wip_logger.log('end outer loop', l_returnStatus);
1007: end if;
1008: end loop;
1009:
1010: --return status has already been set at this point

Line 1012: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',

1008: end loop;
1009:
1010: --return status has already been set at this point
1011: if (l_logLevel <= wip_constants.trace_logging) then
1012: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',
1013: p_procReturnStatus => x_returnStatus,
1014: p_msg => 'procedure success',
1015: x_returnStatus => l_returnStatus); --discard logging return status
1016: end if;

Line 1018: wip_logger.cleanup(x_returnStatus => l_returnStatus);

1014: p_msg => 'procedure success',
1015: x_returnStatus => l_returnStatus); --discard logging return status
1016: end if;
1017: if(fnd_api.to_boolean(p_endDebug)) then
1018: wip_logger.cleanup(x_returnStatus => l_returnStatus);
1019: end if;
1020: exception
1021: when fnd_api.g_exc_unexpected_error then
1022: x_returnStatus := fnd_api.g_ret_sts_unexp_error;

Line 1025: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',

1021: when fnd_api.g_exc_unexpected_error then
1022: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
1023: rollback to wiplotpb_10;
1024: if (l_logLevel <= wip_constants.trace_logging) then
1025: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',
1026: p_procReturnStatus => x_returnStatus,
1027: p_msg => l_errMsg,
1028: x_returnStatus => l_returnStatus); --discard logging return status
1029: end if;

Line 1031: wip_logger.cleanup(x_returnStatus => l_returnStatus);

1027: p_msg => l_errMsg,
1028: x_returnStatus => l_returnStatus); --discard logging return status
1029: end if;
1030: if(fnd_api.to_boolean(p_endDebug)) then
1031: wip_logger.cleanup(x_returnStatus => l_returnStatus);
1032: end if;
1033: when others then
1034: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
1035: rollback to wiplotpb_10;

Line 1040: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',

1036: fnd_msg_pub.add_exc_msg(p_pkg_name => 'wip_autoLotProc_priv',
1037: p_procedure_name => 'deriveLotsFromMTI',
1038: p_error_text => SQLERRM);
1039: if (l_logLevel <= wip_constants.trace_logging) then
1040: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveLotsFromMTI',
1041: p_procReturnStatus => x_returnStatus,
1042: p_msg => 'unexpected error:' || SQLERRM,
1043: x_returnStatus => l_returnStatus); --discard logging return status
1044: end if;

Line 1046: wip_logger.cleanup(x_returnStatus => l_returnStatus);

1042: p_msg => 'unexpected error:' || SQLERRM,
1043: x_returnStatus => l_returnStatus); --discard logging return status
1044: end if;
1045: if(fnd_api.to_boolean(p_endDebug)) then
1046: wip_logger.cleanup(x_returnStatus => l_returnStatus);
1047: end if;
1048: end deriveLotsFromMTI;
1049:
1050:

Line 1112: l_params wip_logger.param_tbl_t;

1108: l_lotNumber VARCHAR2(80);
1109: l_expDate DATE;
1110: l_lotQty NUMBER;
1111: l_cond boolean;
1112: l_params wip_logger.param_tbl_t;
1113: l_errMsg VARCHAR2(80);
1114: l_returnStatus VARCHAR2(1);
1115: l_enabled VARCHAR2(1);
1116: l_logLevel NUMBER := fnd_log.g_current_runtime_level;

Line 1140: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',

1136: l_params(7).paramValue := l_item.revision;
1137: l_params(8).paramName := 'x_compLot(cur_item).primary_quantity';
1138: l_params(8).paramValue := l_item.primary_quantity;
1139: end if;
1140: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',
1141: p_params => l_params,
1142: x_returnStatus => x_returnStatus);
1143: end if;
1144:

Line 1168: wip_logger.log('lot: ' || l_lotNumber || '; qty: ' || l_lotQty, l_returnStatus);

1164: exit when c_negRetTxnBasedLots%NOTFOUND;
1165: end if;
1166:
1167: if (l_logLevel <= wip_constants.full_logging) then
1168: wip_logger.log('lot: ' || l_lotNumber || '; qty: ' || l_lotQty, l_returnStatus);
1169: end if;
1170: l_enabled := wip_utilities.is_status_applicable(p_trx_type_id => getTxnType(l_item.transaction_action_id),
1171: p_organization_id => p_orgID,
1172: p_inventory_item_id => l_item.inventory_item_id,

Line 1179: wip_logger.log('lot is not enabled', l_returnStatus);

1175: p_lot_number => l_lotNumber,
1176: p_object_type => 'O');
1177: if(l_enabled <> 'Y') then
1178: if (l_logLevel <= wip_constants.full_logging) then
1179: wip_logger.log('lot is not enabled', l_returnStatus);
1180: end if;
1181: goto END_OF_LOOP;
1182: end if;
1183: --processing here is slightly different than deriveIssueLots b/c sign of quantities could be either + or -

Line 1212: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',

1208: raise fnd_api.g_exc_error;
1209: end if;
1210:
1211: if (l_logLevel <= wip_constants.trace_logging) then
1212: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',
1213: p_procReturnStatus => x_returnStatus,
1214: p_msg => 'procedure success',
1215: x_returnStatus => l_returnStatus); --discard logging return status
1216: end if;

Line 1222: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',

1218: exception
1219: when fnd_api.g_exc_error then
1220: x_returnStatus:= fnd_api.g_ret_sts_error; --let caller know item was not fully derived
1221: if (l_logLevel <= wip_constants.trace_logging) then
1222: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',
1223: p_procReturnStatus => x_returnStatus,
1224: p_msg => l_errMsg,
1225: x_returnStatus => l_returnStatus); --discard logging return status
1226: end if;

Line 1230: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',

1226: end if;
1227: when fnd_api.g_exc_unexpected_error then
1228: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
1229: if (l_logLevel <= wip_constants.trace_logging) then
1230: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',
1231: p_procReturnStatus => x_returnStatus,
1232: p_msg => 'error: ' || l_errMsg,
1233: x_returnStatus => l_returnStatus); --discard logging return status
1234: end if;

Line 1246: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',

1242: fnd_msg_pub.add_exc_msg(p_pkg_name => 'wip_autoLotProc_priv',
1243: p_procedure_name => 'deriveTxnLots',
1244: p_error_text => SQLERRM);
1245: if (l_logLevel <= wip_constants.trace_logging) then
1246: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveTxnLots',
1247: p_procReturnStatus => x_returnStatus,
1248: p_msg => 'error: ' || SQLERRM,
1249: x_returnStatus => l_returnStatus); --discard logging return status
1250: end if;

Line 1284: l_params wip_logger.param_tbl_t;

1280: l_qtyRsved2 NUMBER;
1281: l_qtySuggested2 NUMBER;
1282: l_qtyAvailToRsv2 NUMBER;
1283: l_qtyAvailToTxt2 NUMBER;
1284: l_params wip_logger.param_tbl_t;
1285: l_cond boolean;
1286: l_enabled VARCHAR2(1);
1287: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
1288: /* Added for Wilson Greatbatch Enhancement */

Line 1391: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',

1387: l_params(7).paramValue := l_item.revision;
1388: l_params(8).paramName := 'x_compLot(cur_item).primary_quantity';
1389: l_params(8).paramValue := l_item.primary_quantity;
1390: end if;
1391: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',
1392: p_params => l_params,
1393: x_returnStatus => x_returnStatus);
1394: end if;
1395:

Line 1554: wip_logger.log ('Changing l_qtyAvailToTxt', l_returnStatus ) ;

1550: /* Begin Bug#4956543. l_qtyAvailToTxt is updated if Lot is already selected */
1551:
1552: if ((l_qtyAvailToTxt > 0) and (l_qtyAvailToTxt - l_lot_qty_selected ) > 0) then
1553: if (l_lot_qty_selected > 0 ) then
1554: wip_logger.log ('Changing l_qtyAvailToTxt', l_returnStatus ) ;
1555: l_qtyAvailToTxt := l_qtyAvailToTxt - l_lot_qty_selected ;
1556: end if ;
1557:
1558: /* End Bug#4956543 */

Line 1561: wip_logger.log('adding lot ' || l_lotNumber || 'w/qty ' || least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);

1557:
1558: /* End Bug#4956543 */
1559:
1560: if (l_logLevel <= wip_constants.full_logging) then
1561: wip_logger.log('adding lot ' || l_lotNumber || 'w/qty ' || least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);
1562: wip_logger.log('qty avail to txt:' || l_qtyAvailToTxt, l_returnStatus);
1563: wip_logger.log('l_rmnQty:' || l_rmnQty, l_returnStatus);
1564: end if;
1565:

Line 1562: wip_logger.log('qty avail to txt:' || l_qtyAvailToTxt, l_returnStatus);

1558: /* End Bug#4956543 */
1559:
1560: if (l_logLevel <= wip_constants.full_logging) then
1561: wip_logger.log('adding lot ' || l_lotNumber || 'w/qty ' || least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);
1562: wip_logger.log('qty avail to txt:' || l_qtyAvailToTxt, l_returnStatus);
1563: wip_logger.log('l_rmnQty:' || l_rmnQty, l_returnStatus);
1564: end if;
1565:
1566: x_compLots.addLot(p_lotNumber => l_lotNumber,

Line 1563: wip_logger.log('l_rmnQty:' || l_rmnQty, l_returnStatus);

1559:
1560: if (l_logLevel <= wip_constants.full_logging) then
1561: wip_logger.log('adding lot ' || l_lotNumber || 'w/qty ' || least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);
1562: wip_logger.log('qty avail to txt:' || l_qtyAvailToTxt, l_returnStatus);
1563: wip_logger.log('l_rmnQty:' || l_rmnQty, l_returnStatus);
1564: end if;
1565:
1566: x_compLots.addLot(p_lotNumber => l_lotNumber,
1567: p_priQty => least(l_rmnQty, l_qtyAvailToTxt),

Line 1600: wip_logger.log('updating treeID' || x_treeID, l_returnStatus);

1596: raise fnd_api.g_exc_unexpected_error;
1597: end if;
1598:
1599: if (l_logLevel <= wip_constants.full_logging) then
1600: wip_logger.log('updating treeID' || x_treeID, l_returnStatus);
1601: wip_logger.log(' item=' || l_item.inventory_item_id, l_returnStatus);
1602: wip_logger.log(' lot=' || l_lotNumber, l_returnStatus);
1603: wip_logger.log(' qty=' || -1 * least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);
1604: end if;

Line 1601: wip_logger.log(' item=' || l_item.inventory_item_id, l_returnStatus);

1597: end if;
1598:
1599: if (l_logLevel <= wip_constants.full_logging) then
1600: wip_logger.log('updating treeID' || x_treeID, l_returnStatus);
1601: wip_logger.log(' item=' || l_item.inventory_item_id, l_returnStatus);
1602: wip_logger.log(' lot=' || l_lotNumber, l_returnStatus);
1603: wip_logger.log(' qty=' || -1 * least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);
1604: end if;
1605: l_rmnQty := l_rmnQty - least(l_rmnQty, l_qtyAvailToTxt);

Line 1602: wip_logger.log(' lot=' || l_lotNumber, l_returnStatus);

1598:
1599: if (l_logLevel <= wip_constants.full_logging) then
1600: wip_logger.log('updating treeID' || x_treeID, l_returnStatus);
1601: wip_logger.log(' item=' || l_item.inventory_item_id, l_returnStatus);
1602: wip_logger.log(' lot=' || l_lotNumber, l_returnStatus);
1603: wip_logger.log(' qty=' || -1 * least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);
1604: end if;
1605: l_rmnQty := l_rmnQty - least(l_rmnQty, l_qtyAvailToTxt);
1606: if(l_rmnQty = 0) then

Line 1603: wip_logger.log(' qty=' || -1 * least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);

1599: if (l_logLevel <= wip_constants.full_logging) then
1600: wip_logger.log('updating treeID' || x_treeID, l_returnStatus);
1601: wip_logger.log(' item=' || l_item.inventory_item_id, l_returnStatus);
1602: wip_logger.log(' lot=' || l_lotNumber, l_returnStatus);
1603: wip_logger.log(' qty=' || -1 * least(l_rmnQty, l_qtyAvailToTxt), l_returnStatus);
1604: end if;
1605: l_rmnQty := l_rmnQty - least(l_rmnQty, l_qtyAvailToTxt);
1606: if(l_rmnQty = 0) then
1607: exit;

Line 1631: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',

1627: raise fnd_api.g_exc_error;
1628: end if;
1629:
1630: if (l_logLevel <= wip_constants.trace_logging) then
1631: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',
1632: p_procReturnStatus => x_returnStatus,
1633: p_msg => 'procedure success',
1634: x_returnStatus => l_returnStatus); --discard logging return status
1635: end if;

Line 1641: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',

1637: exception
1638: when fnd_api.g_exc_error then
1639: x_returnStatus:= fnd_api.g_ret_sts_error; --let caller know item was not fully derived
1640: if (l_logLevel <= wip_constants.trace_logging) then
1641: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',
1642: p_procReturnStatus => x_returnStatus,
1643: p_msg => l_errMsg,
1644: x_returnStatus => l_returnStatus); --discard logging return status
1645: end if;

Line 1654: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',

1650: elsif(c_expDateOrderedLots%ISOPEN) then
1651: close c_expDateOrderedLots;
1652: end if;
1653: if (l_logLevel <= wip_constants.trace_logging) then
1654: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',
1655: p_procReturnStatus => x_returnStatus,
1656: p_msg => 'error: ' || l_errMsg,
1657: x_returnStatus => l_returnStatus); --discard logging return status
1658: end if;

Line 1670: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',

1666: fnd_msg_pub.add_exc_msg(p_pkg_name => 'wip_autoLotProc_priv',
1667: p_procedure_name => 'deriveIssueLots',
1668: p_error_text => SQLERRM);
1669: if (l_logLevel <= wip_constants.trace_logging) then
1670: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveIssueLots',
1671: p_procReturnStatus => x_returnStatus,
1672: p_msg => 'error: ' || SQLERRM,
1673: x_returnStatus => l_returnStatus); --discard logging return status
1674: end if;

Line 1689: l_params wip_logger.param_tbl_t;

1685: x_returnStatus OUT NOCOPY VARCHAR2) is
1686: l_lotControlCode NUMBER;
1687: l_serialControlCode NUMBER;
1688: l_errMsg VARCHAR2(80);
1689: l_params wip_logger.param_tbl_t;
1690: l_returnStatus VARCHAR2(1);
1691: l_item system.wip_component_obj_t;
1692: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
1693: begin

Line 1708: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',

1704: l_params(4).paramValue := p_treeSrcName;
1705: l_params(5).paramName := 'x_treeID';
1706: l_params(5).paramValue := x_treeID;
1707:
1708: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',
1709: p_params => l_params,
1710: x_returnStatus => x_returnStatus);
1711: end if;
1712:

Line 1748: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',

1744: --if uncontrolled, return success (no derivation necessary)
1745: if(l_lotControlCode = wip_constants.no_lot) then
1746: x_returnStatus := fnd_api.g_ret_sts_success;
1747: if (l_logLevel <= wip_constants.trace_logging) then
1748: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',
1749: p_procReturnStatus => x_returnStatus,
1750: p_msg => 'procedure success (no derivation necessary)',
1751: x_returnStatus => l_returnStatus); --discard logging return status
1752: end if;

Line 1793: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',

1789: raise fnd_api.g_exc_unexpected_error;
1790: end if;
1791:
1792: if (l_logLevel <= wip_constants.trace_logging) then
1793: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',
1794: p_procReturnStatus => x_returnStatus,
1795: p_msg => 'procedure success',
1796: x_returnStatus => l_returnStatus); --discard logging return status
1797: end if;

Line 1803: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',

1799: exception
1800: when fnd_api.g_exc_error then
1801: x_returnStatus := fnd_api.g_ret_sts_error;
1802: if (l_logLevel <= wip_constants.trace_logging) then
1803: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',
1804: p_procReturnStatus => x_returnStatus,
1805: p_msg => 'error' || l_errMsg,
1806: x_returnStatus => l_returnStatus); --discard logging return status
1807: end if;

Line 1812: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',

1808: rollback to wipbflpb40;
1809: when fnd_api.g_exc_unexpected_error then
1810: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
1811: if (l_logLevel <= wip_constants.trace_logging) then
1812: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',
1813: p_procReturnStatus => x_returnStatus,
1814: p_msg => 'unexp error raised:',
1815: x_returnStatus => l_returnStatus); --discard logging return status
1816: end if;

Line 1824: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',

1820: fnd_msg_pub.add_exc_msg(p_pkg_name => 'wip_autoLotProc_priv',
1821: p_procedure_name => 'deriveSingleItem',
1822: p_error_text => SQLERRM);
1823: if (l_logLevel <= wip_constants.trace_logging) then
1824: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.deriveSingleItem',
1825: p_procReturnStatus => x_returnStatus,
1826: p_msg => 'unexp error:' || SQLERRM,
1827: x_returnStatus => l_returnStatus); --discard logging return status
1828: end if;

Line 1859: l_params wip_logger.param_tbl_t;

1855: p_txnActionID IN NUMBER,
1856: p_serControlCode IN NUMBER,
1857: x_returnStatus OUT NOCOPY VARCHAR2) IS
1858: l_serCount NUMBER;
1859: l_params wip_logger.param_tbl_t;
1860: l_returnStatus VARCHAR2(1);
1861: l_errMsg VARCHAR2(80);
1862: l_txnTypeID NUMBER;
1863: l_logLevel NUMBER := fnd_log.g_current_runtime_level;

Line 1876: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',

1872: l_params(3).paramName := 'p_qty';
1873: l_params(3).paramValue := p_qty;
1874: l_params(4).paramName := 'p_txnActionID';
1875: l_params(4).paramValue := p_txnActionID;
1876: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',
1877: p_params => l_params,
1878: x_returnStatus => x_returnStatus);
1879: end if;
1880:

Line 1882: wip_logger.log('qty:' || p_qty, l_returnStatus);

1878: x_returnStatus => x_returnStatus);
1879: end if;
1880:
1881: if (l_logLevel <= wip_constants.full_logging) then
1882: wip_logger.log('qty:' || p_qty, l_returnStatus);
1883: wip_logger.log('round(qty)' || round(p_qty), l_returnStatus);
1884: end if;
1885: if(p_qty <> round(p_qty)) then --serial requirements must be whole numbers
1886: l_errMsg := 'serial requirement not a whole #';

Line 1883: wip_logger.log('round(qty)' || round(p_qty), l_returnStatus);

1879: end if;
1880:
1881: if (l_logLevel <= wip_constants.full_logging) then
1882: wip_logger.log('qty:' || p_qty, l_returnStatus);
1883: wip_logger.log('round(qty)' || round(p_qty), l_returnStatus);
1884: end if;
1885: if(p_qty <> round(p_qty)) then --serial requirements must be whole numbers
1886: l_errMsg := 'serial requirement not a whole #';
1887: fnd_message.set_name('WIP', 'COMP_INVALID_SER_QTY');

Line 1942: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',

1938: elsif(p_txnActionID = wip_constants.issnegc_action) then
1939: if(p_serControlCode = wip_constants.dyn_rcv_sn) then
1940: x_returnStatus := fnd_api.g_ret_sts_success;
1941: if (l_logLevel <= wip_constants.trace_logging) then
1942: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',
1943: p_procReturnStatus => x_returnStatus,
1944: p_msg => 'procedure success (neg issue and serial is dyn at recpt)',
1945: x_returnStatus => l_returnStatus);
1946: end if;

Line 1971: wip_logger.log('serial count is ' || l_serCount, l_returnStatus);

1967:
1968: end if;
1969: end if;
1970: if (l_logLevel <= wip_constants.full_logging) then
1971: wip_logger.log('serial count is ' || l_serCount, l_returnStatus);
1972: end if;
1973: if(l_serCount < p_qty) then
1974: fnd_message.set_name('WIP', 'NO_COMP_SERIAL_NUMBERS');
1975: fnd_message.set_token('ITEM', p_itemName);

Line 1983: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',

1979: else
1980: x_returnStatus := fnd_api.g_ret_sts_success;
1981: end if;
1982: if (l_logLevel <= wip_constants.trace_logging) then
1983: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',
1984: p_procReturnStatus => x_returnStatus,
1985: p_msg => 'procedure success',
1986: x_returnStatus => l_returnStatus);
1987: end if;

Line 1992: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',

1988: exception
1989: when fnd_api.g_exc_unexpected_error then
1990: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
1991: if (l_logLevel <= wip_constants.trace_logging) then
1992: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',
1993: p_procReturnStatus => x_returnStatus,
1994: p_msg => l_errMsg,
1995: x_returnStatus => l_returnStatus);
1996: end if;

Line 2003: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',

1999: p_procedure_name => 'checkSerialQuantity',
2000: p_error_text => SQLERRM);
2001: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
2002: if (l_logLevel <= wip_constants.trace_logging) then
2003: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerialQuantity',
2004: p_procReturnStatus => x_returnStatus,
2005: p_msg => 'unexp error ' || SQLERRM,
2006: x_returnStatus => l_returnStatus);
2007: end if;

Line 2032: l_params wip_logger.param_tbl_t;

2028: l_toNumber VARCHAR2(80);
2029: l_errCode NUMBER;
2030: l_errMsg VARCHAR2(80);
2031: l_returnStatus VARCHAR2(1);
2032: l_params wip_logger.param_tbl_t;
2033: l_fmSerial VARCHAR2(30);
2034: l_toSerial VARCHAR2(30);
2035: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
2036: cursor c_tmpSerials is

Line 2072: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',

2068: l_params(10).paramName := 'p_txnActionID';
2069: l_params(10).paramValue := p_txnActionID;
2070: l_params(11).paramName := 'p_serControlCode';
2071: l_params(11).paramValue := p_serControlCode;
2072: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',
2073: p_params => l_params,
2074: x_returnStatus => x_returnStatus);
2075: if(x_returnStatus <> fnd_api.g_ret_sts_success) then
2076: raise fnd_api.g_exc_unexpected_error;

Line 2131: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',

2127:
2128: end if;
2129:
2130: if (l_logLevel <= wip_constants.trace_logging) then
2131: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',
2132: p_procReturnStatus => x_returnStatus,
2133: p_msg => 'procedure success',
2134: x_returnStatus => l_returnStatus);
2135: end if;

Line 2141: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',

2137: when fnd_api.g_exc_error then
2138: x_serialReturnStatus := fnd_api.g_ret_sts_error;
2139: x_returnStatus := fnd_api.g_ret_sts_success;
2140: if (l_logLevel <= wip_constants.trace_logging) then
2141: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',
2142: p_procReturnStatus => x_returnStatus,
2143: p_msg => 'insufficient serial qty. only found ' || l_totalQty,
2144: x_returnStatus => l_returnStatus);
2145: end if;

Line 2155: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',

2151: elsif(c_intSerials%ISOPEN) then
2152: close c_intSerials;
2153: end if;
2154: if (l_logLevel <= wip_constants.trace_logging) then
2155: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',
2156: p_procReturnStatus => x_returnStatus,
2157: p_msg => l_errMsg,
2158: x_returnStatus => l_returnStatus);
2159: end if;

Line 2172: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',

2168: fnd_msg_pub.add_exc_msg(p_pkg_name => 'wip_autoLotProc_priv',
2169: p_procedure_name => 'checkSerial',
2170: p_error_text => SQLERRM);
2171: if (l_logLevel <= wip_constants.trace_logging) then
2172: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.checkSerial',
2173: p_procReturnStatus => x_returnStatus,
2174: p_msg => 'unexp error ' || SQLERRM,
2175: x_returnStatus => l_returnStatus);
2176: end if;

Line 2218: l_params wip_logger.param_tbl_t;

2214: p_lot_qty_selected OUT NOCOPY NUMBER,
2215: x_returnStatus OUT NOCOPY VARCHAR2) is
2216: l_qty NUMBER ;
2217: l_returnStatus varchar2(1) ;
2218: l_params wip_logger.param_tbl_t;
2219: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
2220: begin
2221:
2222: l_qty := 0 ;

Line 2238: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.lot_selected',

2234: l_params(4).paramValue := p_locator_id;
2235: l_params(5).paramName := 'p_lot_number';
2236: l_params(5).paramValue := p_lot_number;
2237:
2238: wip_logger.entryPoint(p_procName => 'wip_autoLotProc_priv.lot_selected',
2239: p_params => l_params,
2240: x_returnStatus => x_returnStatus);
2241: end if ;
2242:

Line 2259: wip_logger.log( 'In exception Lots entered **** ' , l_returnStatus) ;

2255: and lot_number = p_lot_number ;
2256:
2257: exception
2258: when others then
2259: wip_logger.log( 'In exception Lots entered **** ' , l_returnStatus) ;
2260: l_qty := 0 ;
2261: end ;
2262:
2263: p_lot_qty_selected := nvl(l_qty, 0) ;

Line 2265: wip_logger.log( 'Lot Qty Selected ' || p_lot_qty_selected || ' for Lot ' || p_lot_number, l_returnStatus) ;

2261: end ;
2262:
2263: p_lot_qty_selected := nvl(l_qty, 0) ;
2264:
2265: wip_logger.log( 'Lot Qty Selected ' || p_lot_qty_selected || ' for Lot ' || p_lot_number, l_returnStatus) ;
2266:
2267: if (l_logLevel <= wip_constants.trace_logging) then
2268: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.lot_selected',
2269: p_procReturnStatus => x_returnStatus,

Line 2268: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.lot_selected',

2264:
2265: wip_logger.log( 'Lot Qty Selected ' || p_lot_qty_selected || ' for Lot ' || p_lot_number, l_returnStatus) ;
2266:
2267: if (l_logLevel <= wip_constants.trace_logging) then
2268: wip_logger.exitPoint(p_procName => 'wip_autoLotProc_priv.lot_selected',
2269: p_procReturnStatus => x_returnStatus,
2270: p_msg => 'procedure success',
2271: x_returnStatus => l_returnStatus); --discard logging return status
2272: end if;

Line 2311: l_params wip_logger.param_tbl_t;

2307: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
2308: l_errMsg VARCHAR2(240);
2309: l_returnStatus VARCHAR2(1);
2310: l_lotComp c_lotComp%ROWTYPE;
2311: l_params wip_logger.param_tbl_t;
2312:
2313: BEGIN
2314: -- Don't need to check the return status because already check in
2315: -- deriveSerial()

Line 2336: wip_logger.entryPoint(

2332: l_params(8).paramName := 'p_item.primary_quantity';
2333: l_params(8).paramValue := p_item.primary_quantity;
2334: l_params(9).paramName := 'p_item.transaction_action_id';
2335: l_params(9).paramValue := p_item.transaction_action_id;
2336: wip_logger.entryPoint(
2337: p_procName => 'wip_autoLotProc_priv.deriveSingleItemFromMOG',
2338: p_params => l_params,
2339: x_returnStatus => x_returnStatus);
2340: END IF;

Line 2351: wip_logger.log('Added Lot : ' || l_lotComp.lot, l_returnStatus);

2347:
2348: l_derivedQty := l_derivedQty + l_lotComp.lot_qty;
2349:
2350: IF (l_logLevel <= wip_constants.full_logging) THEN
2351: wip_logger.log('Added Lot : ' || l_lotComp.lot, l_returnStatus);
2352: wip_logger.log('Added Lot Qty : '|| l_lotComp.lot_qty, l_returnStatus);
2353: END IF;
2354: END LOOP; -- l_lotComp IN c_lotComp
2355: -- Check whether derived quantity equal to backflush quantity or not

Line 2352: wip_logger.log('Added Lot Qty : '|| l_lotComp.lot_qty, l_returnStatus);

2348: l_derivedQty := l_derivedQty + l_lotComp.lot_qty;
2349:
2350: IF (l_logLevel <= wip_constants.full_logging) THEN
2351: wip_logger.log('Added Lot : ' || l_lotComp.lot, l_returnStatus);
2352: wip_logger.log('Added Lot Qty : '|| l_lotComp.lot_qty, l_returnStatus);
2353: END IF;
2354: END LOOP; -- l_lotComp IN c_lotComp
2355: -- Check whether derived quantity equal to backflush quantity or not
2356: -- If not, error out.

Line 2359: wip_logger.log('item : ' || p_item.item_name, l_returnStatus);

2355: -- Check whether derived quantity equal to backflush quantity or not
2356: -- If not, error out.
2357: IF(p_item.lot_control_code = WIP_CONSTANTS.LOT AND
2358: p_item.primary_quantity <> l_derivedQty * -1) THEN
2359: wip_logger.log('item : ' || p_item.item_name, l_returnStatus);
2360: wip_logger.log('primary_quantity : ' || p_item.primary_quantity,
2361: l_returnStatus);
2362: wip_logger.log('derived_quantity : ' || l_derivedQty, l_returnStatus);
2363: l_errMsg := 'return quantity missmatch';

Line 2360: wip_logger.log('primary_quantity : ' || p_item.primary_quantity,

2356: -- If not, error out.
2357: IF(p_item.lot_control_code = WIP_CONSTANTS.LOT AND
2358: p_item.primary_quantity <> l_derivedQty * -1) THEN
2359: wip_logger.log('item : ' || p_item.item_name, l_returnStatus);
2360: wip_logger.log('primary_quantity : ' || p_item.primary_quantity,
2361: l_returnStatus);
2362: wip_logger.log('derived_quantity : ' || l_derivedQty, l_returnStatus);
2363: l_errMsg := 'return quantity missmatch';
2364: raise fnd_api.g_exc_unexpected_error;

Line 2362: wip_logger.log('derived_quantity : ' || l_derivedQty, l_returnStatus);

2358: p_item.primary_quantity <> l_derivedQty * -1) THEN
2359: wip_logger.log('item : ' || p_item.item_name, l_returnStatus);
2360: wip_logger.log('primary_quantity : ' || p_item.primary_quantity,
2361: l_returnStatus);
2362: wip_logger.log('derived_quantity : ' || l_derivedQty, l_returnStatus);
2363: l_errMsg := 'return quantity missmatch';
2364: raise fnd_api.g_exc_unexpected_error;
2365: END IF;
2366:

Line 2368: wip_logger.exitPoint(

2364: raise fnd_api.g_exc_unexpected_error;
2365: END IF;
2366:
2367: IF (l_logLevel <= wip_constants.trace_logging) THEN
2368: wip_logger.exitPoint(
2369: p_procName => 'wip_autoLotProc_priv.deriveSingleItemFromMOG',
2370: p_procReturnStatus => x_returnStatus,
2371: p_msg => 'procedure success',
2372: x_returnStatus => l_returnStatus); --discard return status

Line 2379: wip_logger.exitPoint(

2375: EXCEPTION
2376: WHEN fnd_api.g_exc_unexpected_error THEN
2377: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
2378: IF (l_logLevel <= wip_constants.trace_logging) THEN
2379: wip_logger.exitPoint(
2380: p_procName => 'wip_autoLotProc_priv.deriveSingleItemFromMOG',
2381: p_procReturnStatus => x_returnStatus,
2382: p_msg => l_errMsg,
2383: x_returnStatus => l_returnStatus); --discard return status

Line 2393: wip_logger.exitPoint(

2389:
2390: WHEN others THEN
2391: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
2392: IF (l_logLevel <= wip_constants.trace_logging) THEN
2393: wip_logger.exitPoint(
2394: p_procName => 'wip_autoLotProc_priv.deriveSingleItemFromMOG',
2395: p_procReturnStatus => x_returnStatus,
2396: p_msg => 'unexp error:' || SQLERRM,
2397: x_returnStatus => l_returnStatus); --discard return status

Line 2433: l_params wip_logger.param_tbl_t;

2429:
2430: l_errMsg VARCHAR2(240);
2431: l_returnStatus VARCHAR2(1);
2432: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
2433: l_params wip_logger.param_tbl_t;
2434: l_revisionComp c_revisionComp%ROWTYPE;
2435: BEGIN
2436:
2437: IF (l_logLevel <= wip_constants.trace_logging) THEN

Line 2456: wip_logger.entryPoint(

2452: l_params(8).paramName := 'p_item.primary_quantity';
2453: l_params(8).paramValue := p_item.primary_quantity;
2454: l_params(9).paramName := 'p_item.transaction_action_id';
2455: l_params(9).paramValue := p_item.transaction_action_id;
2456: wip_logger.entryPoint(
2457: p_procName => 'wip_autoLotProc_priv.setItemRevision',
2458: p_params => l_params,
2459: x_returnStatus => x_returnStatus);
2460: END IF;

Line 2473: wip_logger.exitPoint(

2469: x_compLots.setRevision(p_revision => l_revisionComp.revision);
2470: END IF;
2471:
2472: IF (l_logLevel <= wip_constants.trace_logging) THEN
2473: wip_logger.exitPoint(
2474: p_procName => 'wip_autoLotProc_priv.setItemRevision',
2475: p_procReturnStatus => x_returnStatus,
2476: p_msg => 'procedure success',
2477: x_returnStatus => l_returnStatus); --discard return status

Line 2488: wip_logger.exitPoint(

2484: END IF;
2485:
2486: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
2487: IF (l_logLevel <= wip_constants.trace_logging) THEN
2488: wip_logger.exitPoint(
2489: p_procName => 'wip_autoLotProc_priv.setItemRevision',
2490: p_procReturnStatus => x_returnStatus,
2491: p_msg => 'unexp error:' || SQLERRM,
2492: x_returnStatus => l_returnStatus); --discard return status

Line 2506: l_params wip_logger.param_tbl_t;

2502: x_returnStatus OUT NOCOPY VARCHAR2) IS
2503:
2504: l_returnStatus VARCHAR2(1);
2505: l_errMsg VARCHAR2(80);
2506: l_params wip_logger.param_tbl_t;
2507: l_curItem system.wip_component_obj_t;
2508: l_logLevel NUMBER := fnd_log.g_current_runtime_level;
2509: BEGIN
2510: IF (l_logLevel <= wip_constants.trace_logging) THEN

Line 2516: wip_logger.entryPoint(

2512: l_params(1).paramValue := p_orgID;
2513: l_params(2).paramName := 'p_objectID';
2514: l_params(2).paramValue := p_objectID;
2515:
2516: wip_logger.entryPoint(
2517: p_procName => 'wip_autoLotProc_priv.deriveLotsFromMOG',
2518: p_params => l_params,
2519: x_returnStatus => x_returnStatus);
2520: END IF;

Line 2579: wip_logger.exitPoint(

2575: EXIT WHEN NOT x_compLots.setNextItem;
2576: END LOOP;
2577:
2578: IF (l_logLevel <= wip_constants.trace_logging) THEN
2579: wip_logger.exitPoint(
2580: p_procName => 'wip_autoLotProc_priv.deriveLotsFromMOG',
2581: p_procReturnStatus => x_returnStatus,
2582: p_msg => 'procedure success',
2583: x_returnStatus => l_returnStatus);

Line 2590: wip_logger.exitPoint(

2586: EXCEPTION
2587: WHEN fnd_api.g_exc_unexpected_error THEN
2588: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
2589: IF (l_logLevel <= wip_constants.trace_logging) THEN
2590: wip_logger.exitPoint(
2591: p_procName => 'wip_autoLotProc_priv.deriveLotsFromMOG',
2592: p_procReturnStatus => x_returnStatus,
2593: p_msg => l_errMsg,
2594: x_returnStatus => l_returnStatus); --discard return status

Line 2601: wip_logger.exitPoint(

2597:
2598: WHEN others THEN
2599: x_returnStatus := fnd_api.g_ret_sts_unexp_error;
2600: IF (l_logLevel <= wip_constants.trace_logging) THEN
2601: wip_logger.exitPoint(
2602: p_procName => 'wip_autoLotProc_priv.deriveLotsFromMOG',
2603: p_procReturnStatus => x_returnStatus,
2604: p_msg => 'unexpected error:' || SQLERRM,
2605: x_returnStatus => l_returnStatus); --discard return status