eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.IA_WF_REQUEST_PKG dependencies on IA_WF_UTIL_PKG

Line 111: IA_WF_UTIL_PKG.InitializeDebugMessage;

107: -----------------------------------------------------
108: debugInfo := 'Initialize error message stack';
109: -----------------------------------------------------
110: FA_SRVR_MSG.init_server_message;
111: IA_WF_UTIL_PKG.InitializeDebugMessage;
112:
113:
114: -----------------------------------------------------
115: debugInfo := 'Retrieve book type code from IA_REQUEST_HEADERS';

Line 148: if (l_status is NULL or l_status <> IA_WF_UTIL_PKG.HeaderStatusSubmitted) then

144: l_error_message := FND_MESSAGE.Get;
145: raise localException;
146: end;
147:
148: if (l_status is NULL or l_status <> IA_WF_UTIL_PKG.HeaderStatusSubmitted) then
149: FND_MESSAGE.set_name('IA', 'IA_INVALID_STATUS_FOR_START_WF'); -- Error: You can not submit the request id, REQUEST_ID. The status of request must be set to Submitted in order for Workflow to initiate the request.
150: FND_MESSAGE.set_token('REQUEST_ID', p_request_id);
151: l_error_message := FND_MESSAGE.Get;
152: raise localException;

Line 207: if (l_request_type = IA_WF_UTIL_PKG.RequestTypeTransfer) then

203:
204: -----------------------------------------------------
205: debugInfo := 'Validate Book Type Code';
206: -----------------------------------------------------
207: if (l_request_type = IA_WF_UTIL_PKG.RequestTypeTransfer) then
208:
209: begin
210:
211: select book_type_code

Line 237: and application_id=IA_WF_UTIL_PKG.GetApplicationID;

233: select responsibility_id
234: into l_dummy
235: from fnd_responsibility
236: where responsibility_id=l_responsibility_id
237: and application_id=IA_WF_UTIL_PKG.GetApplicationID;
238:
239: exception
240: when others then
241: FND_MESSAGE.set_name('IA', 'IA_NO_RESPONSIBILITY_FOUND'); -- Error: Unable to find responsibility id, RESPONSIBILITY_ID

Line 265: if (not IA_WF_UTIL_PKG.InitializeProfile(p_user_id => l_preparer_user_id,

261:
262: -----------------------------------------------------
263: debugInfo := 'Initialize Profile';
264: -----------------------------------------------------
265: if (not IA_WF_UTIL_PKG.InitializeProfile(p_user_id => l_preparer_user_id,
266: p_responsibility_id => l_responsibility_id) ) then
267: raise localException;
268: end if;
269:

Line 275: l_rule_id := IA_WF_UTIL_PKG.GetRuleID(p_responsibility_id => l_responsibility_id);

271: debugInfo := 'Get Rule ID';
272: -----------------------------------------------------
273: begin
274:
275: l_rule_id := IA_WF_UTIL_PKG.GetRuleID(p_responsibility_id => l_responsibility_id);
276:
277: exception
278: when others then
279: FND_MESSAGE.set_name('IA', 'IA_NO_RULE_ASSIGNED'); -- Error: No rule has been defined for responsibility id, RESPONSIBILITY_ID.

Line 289: if (not IA_WF_UTIL_PKG.ResetRuleSetup(p_rule_id => l_rule_id,

285:
286: -----------------------------------------------------
287: debugInfo := 'Initialize rule setup';
288: -----------------------------------------------------
289: if (not IA_WF_UTIL_PKG.ResetRuleSetup(p_rule_id => l_rule_id,
290: p_book_type_code => l_book_type_code) ) then
291: FND_MESSAGE.set_name('IA', 'IA_RULE_RETRIEVAL_ERROR'); -- Error: Unable to find rule id, RULE_ID
292: FND_MESSAGE.set_token('RULE_ID', l_rule_id);
293: l_error_message := FND_MESSAGE.Get;

Line 300: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id,

296:
297: -----------------------------------------------------
298: debugInfo := 'Get Approval Type';
299: -----------------------------------------------------
300: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id,
301: p_book_type_code => l_book_type_code);
302:
303: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
304: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

Line 303: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then

299: -----------------------------------------------------
300: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id,
301: p_book_type_code => l_book_type_code);
302:
303: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
304: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
305: else
306: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeReleasing;
307: end if;

Line 304: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

300: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id,
301: p_book_type_code => l_book_type_code);
302:
303: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
304: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
305: else
306: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeReleasing;
307: end if;
308:

Line 306: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeReleasing;

302:
303: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
304: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
305: else
306: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeReleasing;
307: end if;
308:
309: /***************************
310: * Initializing AME session

Line 331: set status = IA_WF_UTIL_PKG.HeaderStatusPendingApproval

327: -----------------------------------------------------
328: debugInfo := 'Set the current request status to Pending';
329: -----------------------------------------------------
330: update ia_request_headers
331: set status = IA_WF_UTIL_PKG.HeaderStatusPendingApproval
332: ,last_update_date = SYSDATE
333: ,last_updated_by = nvl(to_number(FND_PROFILE.VALUE('USER_ID')),-1)
334: ,last_update_login = nvl(to_number(FND_PROFILE.VALUE('LOGIN_ID')),-1)
335: where request_id = p_request_id;

Line 338: set status = IA_WF_UTIL_PKG.LineStatusPending

334: ,last_update_login = nvl(to_number(FND_PROFILE.VALUE('LOGIN_ID')),-1)
335: where request_id = p_request_id;
336:
337: update ia_request_details
338: set status = IA_WF_UTIL_PKG.LineStatusPending
339: ,last_update_date = SYSDATE
340: ,last_updated_by = nvl(to_number(FND_PROFILE.VALUE('USER_ID')),-1)
341: ,last_update_login = nvl(to_number(FND_PROFILE.VALUE('LOGIN_ID')),-1)
342: where request_id = p_request_id;

Line 363: WF_ENGINE.createProcess(ItemType => IA_WF_UTIL_PKG.WF_TransactionType,

359: begin
360: -----------------------------------------------------
361: debugInfo := 'Create a new process';
362: -----------------------------------------------------
363: WF_ENGINE.createProcess(ItemType => IA_WF_UTIL_PKG.WF_TransactionType,
364: ItemKey => l_itemkey,
365: process => IA_WF_UTIL_PKG.WF_MainProcess);
366:
367: exception

Line 365: process => IA_WF_UTIL_PKG.WF_MainProcess);

361: debugInfo := 'Create a new process';
362: -----------------------------------------------------
363: WF_ENGINE.createProcess(ItemType => IA_WF_UTIL_PKG.WF_TransactionType,
364: ItemKey => l_itemkey,
365: process => IA_WF_UTIL_PKG.WF_MainProcess);
366:
367: exception
368: when others then
369: FND_MESSAGE.set_name('IA', 'IA_WF_CREATE_PROCESS_ERROR'); -- Error: Unable to create a workflow process for request id, REQUEST_ID

Line 378: l_system_admin := IA_WF_UTIL_PKG.GetSystemAdministrator;

374:
375:
376: begin
377:
378: l_system_admin := IA_WF_UTIL_PKG.GetSystemAdministrator;
379:
380: -----------------------------------------------------
381: debugInfo := 'Set system item attributes';
382: -----------------------------------------------------

Line 384: WF_ENGINE.SetItemOwner(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

380: -----------------------------------------------------
381: debugInfo := 'Set system item attributes';
382: -----------------------------------------------------
383: if (l_system_admin is NOT NULL) then
384: WF_ENGINE.SetItemOwner(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
385: itemkey => l_itemkey,
386: owner => l_system_admin); -- l_preparer_name);
387: end if;
388:

Line 389: WF_ENGINE.SetItemUserKey(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

385: itemkey => l_itemkey,
386: owner => l_system_admin); -- l_preparer_name);
387: end if;
388:
389: WF_ENGINE.SetItemUserKey(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
390: itemkey => l_itemkey,
391: userkey => p_request_id); -- p_request_id);
392:
393: exception

Line 407: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

403: -----------------------------------------------------
404: debugInfo := 'Set item attributes';
405: -----------------------------------------------------
406: l_attribute := 'REQUEST_ID';
407: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
408: itemkey => l_itemkey,
409: aname => 'REQUEST_ID',
410: avalue => p_request_id);
411:

Line 413: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

409: aname => 'REQUEST_ID',
410: avalue => p_request_id);
411:
412: l_attribute := 'PREPARER_ID';
413: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
414: itemkey => l_itemkey,
415: aname => 'PREPARER_ID',
416: avalue => l_preparer_id);
417:

Line 419: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

415: aname => 'PREPARER_ID',
416: avalue => l_preparer_id);
417:
418: l_attribute := 'PREPARER_NAME';
419: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
420: itemkey => l_itemkey,
421: aname => 'PREPARER_NAME',
422: avalue => l_preparer_name);
423:

Line 425: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

421: aname => 'PREPARER_NAME',
422: avalue => l_preparer_name);
423:
424: l_attribute := 'PREPARER_NAME_DISP';
425: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
426: itemkey => l_itemkey,
427: aname => 'PREPARER_NAME_DISP',
428: avalue => l_preparer_name_display);
429:

Line 431: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

427: aname => 'PREPARER_NAME_DISP',
428: avalue => l_preparer_name_display);
429:
430: l_attribute := 'REQUESTER_ID';
431: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
432: itemkey => l_itemkey,
433: aname => 'REQUESTER_ID',
434: avalue => l_requester_id);
435:

Line 437: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

433: aname => 'REQUESTER_ID',
434: avalue => l_requester_id);
435:
436: l_attribute := 'REQUESTER_NAME';
437: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
438: itemkey => l_itemkey,
439: aname => 'REQUESTER_NAME',
440: avalue => l_requester_name);
441:

Line 443: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

439: aname => 'REQUESTER_NAME',
440: avalue => l_requester_name);
441:
442: l_attribute := 'REQUESTER_NAME_DISP';
443: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
444: itemkey => l_itemkey,
445: aname => 'REQUESTER_NAME_DISP',
446: avalue => l_requester_name_display);
447:

Line 449: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

445: aname => 'REQUESTER_NAME_DISP',
446: avalue => l_requester_name_display);
447:
448: l_attribute := 'DELEGATEE_ID';
449: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
450: itemkey => l_itemkey,
451: aname => 'DELEGATEE_ID',
452: avalue => '');
453:

Line 455: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

451: aname => 'DELEGATEE_ID',
452: avalue => '');
453:
454: l_attribute := 'BOOK_TYPE_CODE';
455: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
456: itemkey => l_itemkey,
457: aname => 'BOOK_TYPE_CODE',
458: avalue => l_book_type_code);
459:

Line 461: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

457: aname => 'BOOK_TYPE_CODE',
458: avalue => l_book_type_code);
459:
460: l_attribute := 'REQUEST_TYPE';
461: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
462: itemkey => l_itemkey,
463: aname => 'REQUEST_TYPE',
464: avalue => l_request_type);
465:

Line 467: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

463: aname => 'REQUEST_TYPE',
464: avalue => l_request_type);
465:
466: l_attribute := 'REQUEST_TYPE_DISP';
467: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
468: itemkey => l_itemkey,
469: aname => 'REQUEST_TYPE_DISP',
470: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQUEST_TYPE',
471: p_lookup_code=>l_request_type));

Line 470: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQUEST_TYPE',

466: l_attribute := 'REQUEST_TYPE_DISP';
467: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
468: itemkey => l_itemkey,
469: aname => 'REQUEST_TYPE_DISP',
470: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQUEST_TYPE',
471: p_lookup_code=>l_request_type));
472:
473: l_attribute := 'REQUEST_PURPOSE';
474: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

Line 474: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

470: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQUEST_TYPE',
471: p_lookup_code=>l_request_type));
472:
473: l_attribute := 'REQUEST_PURPOSE';
474: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
475: itemkey => l_itemkey,
476: aname => 'REQUEST_PURPOSE',
477: avalue => l_purpose);
478:

Line 480: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

476: aname => 'REQUEST_PURPOSE',
477: avalue => l_purpose);
478:
479: l_attribute := 'RULE_ID';
480: WF_ENGINE.SetItemAttrNumber(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
481: itemkey => l_itemkey,
482: aname => 'RULE_ID',
483: avalue => l_rule_id);
484:

Line 486: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

482: aname => 'RULE_ID',
483: avalue => l_rule_id);
484:
485: l_attribute := 'APPROVAL_CHAIN_PHASE';
486: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
487: itemkey => l_itemkey,
488: aname => 'APPROVAL_CHAIN_PHASE',
489: avalue => l_chain_phase);
490:

Line 492: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

488: aname => 'APPROVAL_CHAIN_PHASE',
489: avalue => l_chain_phase);
490:
491: l_attribute := 'APPROVAL_CHAIN_PHASE_DISP';
492: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
493: itemkey => l_itemkey,
494: aname => 'APPROVAL_CHAIN_PHASE_DISP',
495: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'APPROVAL_TYPE',
496: p_lookup_code=>l_chain_phase));

Line 495: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'APPROVAL_TYPE',

491: l_attribute := 'APPROVAL_CHAIN_PHASE_DISP';
492: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
493: itemkey => l_itemkey,
494: aname => 'APPROVAL_CHAIN_PHASE_DISP',
495: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'APPROVAL_TYPE',
496: p_lookup_code=>l_chain_phase));
497:
498: l_attribute := 'NO_MORE_APPROVER_FLAG';
499: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

Line 499: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

495: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'APPROVAL_TYPE',
496: p_lookup_code=>l_chain_phase));
497:
498: l_attribute := 'NO_MORE_APPROVER_FLAG';
499: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
500: itemkey => l_itemkey,
501: aname => 'NO_MORE_APPROVER_FLAG',
502: avalue => 'N');
503:

Line 506: WF_ENGINE.SetItemAttrDate(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

502: avalue => 'N');
503:
504: /** Reference for settting other item types
505:
506: WF_ENGINE.SetItemAttrDate(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
507: itemkey => l_itemkey,
508: aname => 'AAA_DATE',
509: avalue => p_aaa_date);
510: ***/

Line 513: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

509: avalue => p_aaa_date);
510: ***/
511:
512: l_attribute := 'REQUEST_STATUS';
513: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
514: itemkey => l_itemkey,
515: aname => 'REQUEST_STATUS',
516: avalue => IA_WF_UTIL_PKG.HeaderStatusPendingApproval);
517:

Line 516: avalue => IA_WF_UTIL_PKG.HeaderStatusPendingApproval);

512: l_attribute := 'REQUEST_STATUS';
513: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
514: itemkey => l_itemkey,
515: aname => 'REQUEST_STATUS',
516: avalue => IA_WF_UTIL_PKG.HeaderStatusPendingApproval);
517:
518: l_attribute := 'REQUEST_STATUS_DISP';
519: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
520: itemkey => l_itemkey,

Line 519: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

515: aname => 'REQUEST_STATUS',
516: avalue => IA_WF_UTIL_PKG.HeaderStatusPendingApproval);
517:
518: l_attribute := 'REQUEST_STATUS_DISP';
519: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
520: itemkey => l_itemkey,
521: aname => 'REQUEST_STATUS_DISP',
522: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
523: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusPendingApproval));

Line 522: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',

518: l_attribute := 'REQUEST_STATUS_DISP';
519: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
520: itemkey => l_itemkey,
521: aname => 'REQUEST_STATUS_DISP',
522: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
523: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusPendingApproval));
524: exception
525: when others then
526: FND_MESSAGE.set_name('IA', 'IA_WF_SET_ATTRIBUTE_ERROR'); -- Error: Unable to set the workflow attribute ATTRIBUTE for request id, REQUEST_ID

Line 523: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusPendingApproval));

519: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
520: itemkey => l_itemkey,
521: aname => 'REQUEST_STATUS_DISP',
522: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
523: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusPendingApproval));
524: exception
525: when others then
526: FND_MESSAGE.set_name('IA', 'IA_WF_SET_ATTRIBUTE_ERROR'); -- Error: Unable to set the workflow attribute ATTRIBUTE for request id, REQUEST_ID
527: FND_MESSAGE.set_token('ATTRIBUTE', l_attribute);

Line 538: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => l_itemkey,

534: begin
535:
536: -----------------------------------------------------
537: debugInfo := 'Start Work Flow process';
538: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => l_itemkey,
539: p_calling_fn => callingProgram,
540: p_parameter1 => debugInfo);
541: -----------------------------------------------------
542: WF_ENGINE.StartProcess(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

Line 542: WF_ENGINE.StartProcess(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

538: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => l_itemkey,
539: p_calling_fn => callingProgram,
540: p_parameter1 => debugInfo);
541: -----------------------------------------------------
542: WF_ENGINE.StartProcess(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
543: itemkey => l_itemkey);
544:
545: exception
546: when others then

Line 569: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');

565: */
566: WHEN localException THEN
567: rollback to START_PROCESS_STEP1;
568: FA_SRVR_MSG.add_message(calling_fn => l_error_message);
569: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');
570:
571: return -1;
572:
573: WHEN localWFException THEN

Line 576: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');

572:
573: WHEN localWFException THEN
574: rollback to START_PROCESS_STEP1;
575: FA_SRVR_MSG.add_message(calling_fn => l_error_message);
576: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');
577: /*
578: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,
579: p_calling_fn => callingProgram,
580: p_parameter1 => debugInfo||' '||l_error_message);

Line 578: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,

574: rollback to START_PROCESS_STEP1;
575: FA_SRVR_MSG.add_message(calling_fn => l_error_message);
576: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');
577: /*
578: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,
579: p_calling_fn => callingProgram,
580: p_parameter1 => debugInfo||' '||l_error_message);
581: */
582:

Line 588: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

584:
585: WHEN OTHERS THEN
586: rollback to START_PROCESS_STEP1;
587: FA_SRVR_MSG.Add_SQL_Error(calling_fn => callingProgram);
588: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
589:
590: return -1;
591:
592: END Start_Process;

Line 615: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,

611:
612:
613: -----------------------------------------------------
614: debugInfo := 'Calling AbortProcess';
615: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,
616: p_calling_fn => callingProgram,
617: p_parameter1 => debugInfo);
618: -----------------------------------------------------
619:

Line 620: WF_ENGINE.AbortProcess(IA_WF_UTIL_PKG.WF_TransactionType,

616: p_calling_fn => callingProgram,
617: p_parameter1 => debugInfo);
618: -----------------------------------------------------
619:
620: WF_ENGINE.AbortProcess(IA_WF_UTIL_PKG.WF_TransactionType,
621: p_request_id);
622:
623: commit;
624:

Line 632: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

628:
629: WHEN OTHERS THEN
630: rollback to ABORT_PROCESS_STEP1;
631: FA_SRVR_MSG.Add_SQL_Error(calling_fn => callingProgram);
632: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
633:
634: return -1; -- If errored out
635:
636: END Abort_Process;

Line 673: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

669: if (funcmode = 'RUN') then
670:
671: -----------------------------------------------------
672: debugInfo := 'Get rule ID';
673: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
674: p_calling_fn => callingProgram,
675: p_parameter1 => debugInfo);
676: -----------------------------------------------------
677: l_rule_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 683: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

679: ,aname => 'RULE_ID');
680:
681: -----------------------------------------------------
682: debugInfo := 'Get Book Type Code';
683: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
684: p_calling_fn => callingProgram,
685: p_parameter1 => debugInfo);
686: -----------------------------------------------------
687: l_book_type_code := WF_ENGINE.GetItemAttrText(itemtype => itemtype

Line 693: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

689: ,aname => 'BOOK_TYPE_CODE');
690:
691: -----------------------------------------------------
692: debugInfo := 'Get Approval Type';
693: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
694: p_calling_fn => callingProgram,
695: p_parameter1 => debugInfo);
696: -----------------------------------------------------
697: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id

Line 697: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id

693: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
694: p_calling_fn => callingProgram,
695: p_parameter1 => debugInfo);
696: -----------------------------------------------------
697: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id
698: ,p_book_type_code => l_book_type_code);
699:
700: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeNone) then
701: l_approvals_required := 'NO';

Line 700: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeNone) then

696: -----------------------------------------------------
697: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id
698: ,p_book_type_code => l_book_type_code);
699:
700: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeNone) then
701: l_approvals_required := 'NO';
702: else
703: l_approvals_required := 'YES';
704: end if;

Line 710: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

706:
707: begin
708:
709: l_attribute := 'APPROVALS_REQUIRED';
710: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
711: itemkey => itemkey,
712: aname => 'APPROVALS_REQUIRED',
713: avalue => l_approvals_required);
714: exception

Line 734: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');

730:
731: EXCEPTION
732: WHEN localWFException THEN
733: FA_SRVR_MSG.add_message(calling_fn => l_error_message);
734: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');
735: result := 'COMPLETE:ERROR';
736: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
737: itemtype, itemkey, to_char(actid), debugInfo);
738: RAISE;

Line 736: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

732: WHEN localWFException THEN
733: FA_SRVR_MSG.add_message(calling_fn => l_error_message);
734: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo||' '||l_error_message, 'Error');
735: result := 'COMPLETE:ERROR';
736: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
737: itemtype, itemkey, to_char(actid), debugInfo);
738: RAISE;
739:
740: WHEN OTHERS THEN

Line 745: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

741: FA_SRVR_MSG.add_message(
742: calling_fn => callingProgram||':'||debugInfo);
743: FA_SRVR_MSG.Add_SQL_Error(
744: calling_fn => callingProgram);
745: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
746: result := 'COMPLETE:ERROR';
747:
748: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
749: itemtype, itemkey, to_char(actid), debugInfo);

Line 748: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

744: calling_fn => callingProgram);
745: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
746: result := 'COMPLETE:ERROR';
747:
748: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
749: itemtype, itemkey, to_char(actid), debugInfo);
750: RAISE;
751:
752: END Check_Approval_Type;

Line 796: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

792: if (funcmode = 'RUN') then
793:
794: -----------------------------------------------------
795: debugInfo := 'Get item attributes';
796: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
797: p_calling_fn => callingProgram,
798: p_parameter1 => debugInfo);
799: -----------------------------------------------------
800: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 812: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

808:
809: -----------------------------------------------------
810: -- debugInfo := 'Get next approver ID';
811: debugInfo := 'Get next approver ID: l_chain_phase='||l_chain_phase;
812: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
813: p_calling_fn => callingProgram,
814: p_parameter1 => debugInfo);
815: -----------------------------------------------------
816: if (not IA_AME_REQUEST_PKG.GetNextApprover(RequestId => l_request_id

Line 837: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'APPROVAL_TYPE',

833:
834: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
835: itemkey => itemkey,
836: aname => 'APPROVAL_CHAIN_PHASE_DISP',
837: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'APPROVAL_TYPE',
838: p_lookup_code=>l_chain_phase));
839:
840: if (l_approver_id is NULL) then
841: -----------------------------------------------------

Line 843: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

839:
840: if (l_approver_id is NULL) then
841: -----------------------------------------------------
842: debugInfo := 'Logic for finally approved';
843: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
844: p_calling_fn => callingProgram,
845: p_parameter1 => debugInfo);
846: -----------------------------------------------------
847: WF_ENGINE.SetItemAttrText(itemtype => itemtype,

Line 854: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

850: avalue => 'Y');
851:
852: result := 'COMPLETE:NOT_FOUND';
853:
854: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
855: p_calling_fn => callingProgram,
856: p_parameter1 => debugInfo);
857:
858: else

Line 862: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

858: else
859:
860: -----------------------------------------------------
861: debugInfo := 'Derive the role name for the approver ID from DIRECTORY and set item attributes';
862: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
863: p_calling_fn => callingProgram,
864: p_parameter1 => debugInfo);
865: -----------------------------------------------------
866:

Line 921: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

917: FA_SRVR_MSG.add_message(
918: calling_fn => callingProgram||':'||debugInfo);
919: FA_SRVR_MSG.Add_SQL_Error(
920: calling_fn => callingProgram);
921: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
922: result := 'COMPLETE:ERROR';
923:
924: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
925: itemtype, itemkey, to_char(actid), debugInfo);

Line 924: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

920: calling_fn => callingProgram);
921: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
922: result := 'COMPLETE:ERROR';
923:
924: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
925: itemtype, itemkey, to_char(actid), debugInfo);
926: RAISE;
927:
928:

Line 1012: IA_WF_UTIL_PKG.InitializeDebugMessage;

1008: -----------------------------------------------------
1009: debugInfo := 'Initialize error message stack';
1010: -----------------------------------------------------
1011: FA_SRVR_MSG.init_server_message;
1012: IA_WF_UTIL_PKG.InitializeDebugMessage;
1013:
1014: -----------------------------------------------------
1015: debugInfo := 'Check if the given request_id is valid';
1016: -----------------------------------------------------

Line 1028: and status=IA_WF_UTIL_PKG.ApprovalStatusPendingApproval;

1024: select max(approval_id)
1025: into l_approval_id
1026: from ia_request_approvals
1027: where request_id=p_request_id
1028: and status=IA_WF_UTIL_PKG.ApprovalStatusPendingApproval;
1029:
1030: exception
1031: when others then
1032: FND_MESSAGE.set_name('IA', 'IA_NO_REQUEST_FOUND'); -- Error: Unable to find request id, REQUEST_ID

Line 1117: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,

1113:
1114: WHEN localException THEN
1115: rollback to RESPOND_STEP1;
1116: FA_SRVR_MSG.add_message(calling_fn => l_error_message);
1117: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,
1118: p_calling_fn => callingProgram,
1119: p_parameter1 => debugInfo||' '||l_error_message);
1120:
1121: return -1;

Line 1126: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,

1122:
1123: WHEN OTHERS THEN
1124: rollback to RESPOND_STEP1;
1125: FA_SRVR_MSG.add_message(calling_fn => l_error_message);
1126: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => p_request_id,
1127: p_calling_fn => callingProgram,
1128: p_parameter1 => debugInfo||' '||l_error_message);
1129:
1130: return -1;

Line 1169: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1165:
1166: * COMMENTED OUT DUE TO NEW STANDARD WORKFLOW
1167: -----------------------------------------------------
1168: debugInfo := 'Get request ID';
1169: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1170: p_calling_fn => callingProgram,
1171: p_parameter1 => debugInfo);
1172: -----------------------------------------------------
1173: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1184: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1180: ,aname => 'APPROVAL_CHAIN_PHASE');
1181:
1182: -----------------------------------------------------
1183: debugInfo := 'Get approver ID';
1184: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1185: p_calling_fn => callingProgram,
1186: p_parameter1 => debugInfo);
1187: -----------------------------------------------------
1188: l_approver_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1194: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1190: ,aname => 'APPROVER_ID');
1191:
1192: -----------------------------------------------------
1193: debugInfo := 'Insert into IA_REQUEST_APPROVALS table the next approver with status of Pending Approval';
1194: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1195: p_calling_fn => callingProgram,
1196: p_parameter1 => debugInfo);
1197: -----------------------------------------------------
1198: Insert_Approval(p_request_id => l_request_id

Line 1200: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusPendingApproval

1196: p_parameter1 => debugInfo);
1197: -----------------------------------------------------
1198: Insert_Approval(p_request_id => l_request_id
1199: ,p_approver_id => l_approver_id
1200: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusPendingApproval
1201: ,p_approval_chain_phase => l_chain_phase
1202: ,p_approval_id => l_approval_id);
1203:
1204:

Line 1207: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1203:
1204:
1205: -----------------------------------------------------
1206: debugInfo := 'Set approval ID';
1207: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1208: p_calling_fn => callingProgram,
1209: p_parameter1 => debugInfo);
1210: -----------------------------------------------------
1211: WF_ENGINE.SetItemAttrNumber(itemtype => itemtype

Line 1218: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1214: ,avalue => l_approval_id);
1215:
1216: -----------------------------------------------------
1217: debugInfo := 'Insert into IA_APPROVERS_LIST_T';
1218: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1219: p_calling_fn => callingProgram,
1220: p_parameter1 => debugInfo);
1221:
1222: -----------------------------------------------------

Line 1224: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1220: p_parameter1 => debugInfo);
1221:
1222: -----------------------------------------------------
1223: debugInfo := 'Calling IA_AME_REQUEST_PKG.GetAllApprovers';
1224: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1225: p_calling_fn => callingProgram,
1226: p_parameter1 => debugInfo);
1227:
1228: -----------------------------------------------------

Line 1256: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

1252: FA_SRVR_MSG.add_message(
1253: calling_fn => callingProgram||':'||debugInfo);
1254: FA_SRVR_MSG.Add_SQL_Error(
1255: calling_fn => callingProgram);
1256: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1257: result := 'COMPLETE:ERROR';
1258:
1259: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
1260: itemtype, itemkey, to_char(actid), debugInfo);

Line 1259: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

1255: calling_fn => callingProgram);
1256: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1257: result := 'COMPLETE:ERROR';
1258:
1259: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
1260: itemtype, itemkey, to_char(actid), debugInfo);
1261: RAISE;
1262:
1263: END Insert_Next_Approver;

Line 1337: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

1333: FA_SRVR_MSG.add_message(
1334: calling_fn => callingProgram||':'||debugInfo);
1335: FA_SRVR_MSG.Add_SQL_Error(
1336: calling_fn => callingProgram);
1337: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1338: END Insert_Approval;
1339: */
1340:
1341: /*

Line 1376: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1372: BEGIN
1373:
1374: -----------------------------------------------------
1375: debugInfo := 'Delete rows from IA_APPROVERS_LIST_T';
1376: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1377: p_calling_fn => callingProgram,
1378: p_parameter1 => debugInfo);
1379:
1380: -----------------------------------------------------

Line 1396: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeReleasing;

1392: for l_phase_id in 1 .. 2 loop
1393:
1394: if ( l_phase_id = 1 ) then
1395: tempApprovers := p_releasing_approvers;
1396: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeReleasing;
1397: else
1398: tempApprovers := p_receiving_approvers;
1399: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
1400: end if;

Line 1399: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

1395: tempApprovers := p_releasing_approvers;
1396: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeReleasing;
1397: else
1398: tempApprovers := p_receiving_approvers;
1399: l_chain_phase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
1400: end if;
1401:
1402: for i in 1 .. tempApprovers.count loop
1403:

Line 1418: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1414: elsif (l_ame_approval_status is NULL and l_pending_approver_skipped = 'Y') then
1415:
1416: -----------------------------------------------------
1417: debugInfo := 'Get a new list ID';
1418: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1419: p_calling_fn => callingProgram,
1420: p_parameter1 => debugInfo);
1421: -----------------------------------------------------
1422: select ia_approvers_list_t_s.nextval

Line 1430: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1426: l_approver_id := tempApprovers(i).person_id;
1427:
1428: -----------------------------------------------------
1429: debugInfo := 'Insert into IA_APPROVERS_LIST_T';
1430: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1431: p_calling_fn => callingProgram,
1432: p_parameter1 => debugInfo);
1433: -----------------------------------------------------
1434: insert into ia_approvers_list_t

Line 1451: ,IA_WF_UTIL_PKG.ApprovalStatusPendingApproval -- PENDING

1447: values(l_list_id
1448: ,p_request_id
1449: ,l_approver_id
1450: ,l_approval_order
1451: ,IA_WF_UTIL_PKG.ApprovalStatusPendingApproval -- PENDING
1452: ,l_chain_phase
1453: ,nvl(to_number(FND_PROFILE.VALUE('USER_ID')),-1)
1454: ,sysdate
1455: ,sysdate

Line 1475: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

1471: FA_SRVR_MSG.add_message(
1472: calling_fn => callingProgram||':'||debugInfo);
1473: FA_SRVR_MSG.Add_SQL_Error(
1474: calling_fn => callingProgram);
1475: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1476: END Repopulate_Approvers_List;
1477: */
1478:
1479:

Line 1596: and status = IA_WF_UTIL_PKG.LineStatusPending;

1592: ,last_update_date = SYSDATE
1593: ,last_updated_by = nvl(to_number(FND_PROFILE.VALUE('USER_ID')),-1)
1594: ,last_update_login = nvl(to_number(FND_PROFILE.VALUE('LOGIN_ID')),-1)
1595: where request_id = p_request_id
1596: and status = IA_WF_UTIL_PKG.LineStatusPending;
1597:
1598: COMMIT;
1599:
1600: END Update_Request_Line_Status;

Line 1688: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1684:
1685: if (funcmode = 'RUN') then
1686: -----------------------------------------------------
1687: debugInfo := 'Get request ID';
1688: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1689: p_calling_fn => callingProgram,
1690: p_parameter1 => debugInfo);
1691: -----------------------------------------------------
1692: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1703: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1699: ,aname => 'APPROVAL_CHAIN_PHASE');
1700:
1701: -----------------------------------------------------
1702: debugInfo := 'Get approval ID';
1703: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1704: p_calling_fn => callingProgram,
1705: p_parameter1 => debugInfo);
1706: -----------------------------------------------------
1707: l_approval_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1713: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1709: ,aname => 'APPROVAL_ID');
1710:
1711: -----------------------------------------------------
1712: debugInfo := 'Get approver ID';
1713: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1714: p_calling_fn => callingProgram,
1715: p_parameter1 => debugInfo);
1716: -----------------------------------------------------
1717: l_approver_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1726: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1722: tempApprover.approval_status := AME_UTIL.approvedStatus;
1723:
1724: -----------------------------------------------------
1725: debugInfo := 'Update Approval Status';
1726: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1727: p_calling_fn => callingProgram,
1728: p_parameter1 => debugInfo);
1729: -----------------------------------------------------
1730: -- Bug#5002756: Disabled UpdateApprovalStatus in case of CostCenter method

Line 1731: if (IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

1727: p_calling_fn => callingProgram,
1728: p_parameter1 => debugInfo);
1729: -----------------------------------------------------
1730: -- Bug#5002756: Disabled UpdateApprovalStatus in case of CostCenter method
1731: if (IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => WF_ENGINE.GetItemAttrNumber(itemtype => itemtype
1732: ,itemkey => itemkey
1733: ,aname => 'RULE_ID')
1734: ,p_book_type_code => WF_ENGINE.GetItemAttrText(itemtype => itemtype
1735: ,itemkey => itemkey

Line 1738: = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then

1734: ,p_book_type_code => WF_ENGINE.GetItemAttrText(itemtype => itemtype
1735: ,itemkey => itemkey
1736: ,aname => 'BOOK_TYPE_CODE')
1737: )
1738: = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then
1739:
1740: if (not IA_AME_REQUEST_PKG.UpdateApprovalStatus(RequestId => l_request_id
1741: ,ChainPhase => l_chain_phase
1742: ,Approver => tempApprover)) then

Line 1751: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1747: end if;
1748:
1749: -----------------------------------------------------
1750: debugInfo := 'Set the current approval status to Approved';
1751: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1752: p_calling_fn => callingProgram,
1753: p_parameter1 => debugInfo);
1754: -----------------------------------------------------
1755: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW

Line 1758: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusApproved);

1754: -----------------------------------------------------
1755: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW
1756: Update_Approval_Status(p_approval_id => l_approval_id
1757: ,p_chain_phase => l_chain_phase
1758: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusApproved);
1759: */
1760:
1761: elsif (funcmode = 'CANCEL') THEN
1762:

Line 1773: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

1769: FA_SRVR_MSG.add_message(
1770: calling_fn => callingProgram||':'||debugInfo);
1771: FA_SRVR_MSG.Add_SQL_Error(
1772: calling_fn => callingProgram);
1773: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1774: result := 'COMPLETE:ERROR';
1775:
1776: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
1777: itemtype, itemkey, to_char(actid), debugInfo);

Line 1776: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

1772: calling_fn => callingProgram);
1773: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1774: result := 'COMPLETE:ERROR';
1775:
1776: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
1777: itemtype, itemkey, to_char(actid), debugInfo);
1778: RAISE;
1779:
1780: END Process_Approved;

Line 1812: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1808:
1809: if (funcmode = 'RUN') then
1810: -----------------------------------------------------
1811: debugInfo := 'Get request ID';
1812: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1813: p_calling_fn => callingProgram,
1814: p_parameter1 => debugInfo);
1815: -----------------------------------------------------
1816: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1827: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1823: ,aname => 'APPROVAL_CHAIN_PHASE');
1824:
1825: -----------------------------------------------------
1826: debugInfo := 'Get current approval ID';
1827: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1828: p_calling_fn => callingProgram,
1829: p_parameter1 => debugInfo);
1830: -----------------------------------------------------
1831: l_approval_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1837: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1833: ,aname => 'APPROVAL_ID');
1834:
1835: -----------------------------------------------------
1836: debugInfo := 'Get approver ID';
1837: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1838: p_calling_fn => callingProgram,
1839: p_parameter1 => debugInfo);
1840: -----------------------------------------------------
1841: l_approver_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1845: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, l_approver_id);

1841: l_approver_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype
1842: ,itemkey => itemkey
1843: ,aname => 'APPROVER_ID');
1844:
1845: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, l_approver_id);
1846:
1847: -----------------------------------------------------
1848: debugInfo := 'Get delegatee ID';
1849: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

Line 1849: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1845: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, l_approver_id);
1846:
1847: -----------------------------------------------------
1848: debugInfo := 'Get delegatee ID';
1849: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1850: p_calling_fn => callingProgram,
1851: p_parameter1 => debugInfo);
1852: -----------------------------------------------------
1853: l_delegatee_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1857: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, l_delegatee_id);

1853: l_delegatee_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype
1854: ,itemkey => itemkey
1855: ,aname => 'DELEGATEE_ID');
1856:
1857: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, l_delegatee_id);
1858:
1859: tempApprover.user_id := NULL;
1860: tempApprover.person_id := l_approver_id;
1861: tempApprover.authority := AME_UTIL.authorityApprover; -- ???

Line 1871: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1867: tempDelegatee.approval_status := NULL;
1868:
1869: -----------------------------------------------------
1870: debugInfo := 'Update AME Approval Status';
1871: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1872: p_calling_fn => callingProgram,
1873: p_parameter1 => debugInfo);
1874: -----------------------------------------------------
1875: -- Bug#5002756: Disabled UpdateApprovalStatus in case of CostCenter method

Line 1876: if (IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

1872: p_calling_fn => callingProgram,
1873: p_parameter1 => debugInfo);
1874: -----------------------------------------------------
1875: -- Bug#5002756: Disabled UpdateApprovalStatus in case of CostCenter method
1876: if (IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => WF_ENGINE.GetItemAttrNumber(itemtype => itemtype
1877: ,itemkey => itemkey
1878: ,aname => 'RULE_ID')
1879: ,p_book_type_code => WF_ENGINE.GetItemAttrText(itemtype => itemtype
1880: ,itemkey => itemkey

Line 1883: = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then

1879: ,p_book_type_code => WF_ENGINE.GetItemAttrText(itemtype => itemtype
1880: ,itemkey => itemkey
1881: ,aname => 'BOOK_TYPE_CODE')
1882: )
1883: = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then
1884: if (not IA_AME_REQUEST_PKG.UpdateApprovalStatus(RequestId => l_request_id
1885: ,ChainPhase => l_chain_phase
1886: ,Approver => tempApprover
1887: ,Forwardee => tempDelegatee)) then

Line 1896: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1892: end if;
1893:
1894: -----------------------------------------------------
1895: debugInfo := 'Set the current approval status to Delegated';
1896: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1897: p_calling_fn => callingProgram,
1898: p_parameter1 => debugInfo);
1899: -----------------------------------------------------
1900: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW

Line 1903: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusDelegated);

1899: -----------------------------------------------------
1900: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW
1901: Update_Approval_Status(p_approval_id => l_approval_id
1902: ,p_chain_phase => l_chain_phase
1903: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusDelegated);
1904: */
1905:
1906: elsif (funcmode = 'CANCEL') THEN
1907:

Line 1918: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

1914: FA_SRVR_MSG.add_message(
1915: calling_fn => callingProgram||':'||debugInfo);
1916: FA_SRVR_MSG.Add_SQL_Error(
1917: calling_fn => callingProgram);
1918: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1919: result := 'COMPLETE:ERROR';
1920:
1921: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram||'--'||debugInfo||'--SQLERRM:'||substr(sqlerrm, 1, 240),
1922: itemtype, itemkey, to_char(actid), debugInfo);

Line 1921: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram||'--'||debugInfo||'--SQLERRM:'||substr(sqlerrm, 1, 240),

1917: calling_fn => callingProgram);
1918: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
1919: result := 'COMPLETE:ERROR';
1920:
1921: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram||'--'||debugInfo||'--SQLERRM:'||substr(sqlerrm, 1, 240),
1922: itemtype, itemkey, to_char(actid), debugInfo);
1923: RAISE;
1924:
1925: END Process_Delegated;

Line 1955: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1951:
1952: if (funcmode = 'RUN') then
1953: -----------------------------------------------------
1954: debugInfo := 'Get request ID';
1955: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1956: p_calling_fn => callingProgram,
1957: p_parameter1 => debugInfo);
1958: -----------------------------------------------------
1959: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1970: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1966: ,aname => 'APPROVAL_CHAIN_PHASE');
1967:
1968: -----------------------------------------------------
1969: debugInfo := 'Get approval ID';
1970: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1971: p_calling_fn => callingProgram,
1972: p_parameter1 => debugInfo);
1973: -----------------------------------------------------
1974: l_approval_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1980: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1976: ,aname => 'APPROVAL_ID');
1977:
1978: -----------------------------------------------------
1979: debugInfo := 'Get approver ID';
1980: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1981: p_calling_fn => callingProgram,
1982: p_parameter1 => debugInfo);
1983: -----------------------------------------------------
1984: l_approver_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 1993: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

1989: tempApprover.approval_status := AME_UTIL.rejectStatus;
1990:
1991: -----------------------------------------------------
1992: debugInfo := 'Update Approval Status';
1993: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
1994: p_calling_fn => callingProgram,
1995: p_parameter1 => debugInfo);
1996: -----------------------------------------------------
1997: -- Bug#5002756: Disabled UpdateApprovalStatus in case of CostCenter method

Line 1998: if (IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

1994: p_calling_fn => callingProgram,
1995: p_parameter1 => debugInfo);
1996: -----------------------------------------------------
1997: -- Bug#5002756: Disabled UpdateApprovalStatus in case of CostCenter method
1998: if (IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => WF_ENGINE.GetItemAttrNumber(itemtype => itemtype
1999: ,itemkey => itemkey
2000: ,aname => 'RULE_ID')
2001: ,p_book_type_code => WF_ENGINE.GetItemAttrText(itemtype => itemtype
2002: ,itemkey => itemkey

Line 2005: = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then

2001: ,p_book_type_code => WF_ENGINE.GetItemAttrText(itemtype => itemtype
2002: ,itemkey => itemkey
2003: ,aname => 'BOOK_TYPE_CODE')
2004: )
2005: = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then
2006: if (not IA_AME_REQUEST_PKG.UpdateApprovalStatus(RequestId => l_request_id
2007: ,ChainPhase => l_chain_phase
2008: ,Approver => tempApprover)) then
2009: FND_MESSAGE.set_name('IA', 'IA_AME_UPDATE_STATUS_ERROR'); -- Error occurred when updating approval status in Oracle Approvals Management.

Line 2017: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2013: end if;
2014:
2015: -----------------------------------------------------
2016: debugInfo := 'Set the current approval status to Rejected';
2017: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2018: p_calling_fn => callingProgram,
2019: p_parameter1 => debugInfo);
2020: -----------------------------------------------------
2021: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW

Line 2024: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusRejected);

2020: -----------------------------------------------------
2021: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW
2022: Update_Approval_Status(p_approval_id => l_approval_id
2023: ,p_chain_phase => l_chain_phase
2024: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusRejected);
2025: */
2026:
2027: -----------------------------------------------------
2028: debugInfo := 'Set the current request status to Rejected';

Line 2029: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2025: */
2026:
2027: -----------------------------------------------------
2028: debugInfo := 'Set the current request status to Rejected';
2029: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2030: p_calling_fn => callingProgram,
2031: p_parameter1 => debugInfo);
2032: -----------------------------------------------------
2033: Update_Request_Header_Status(p_request_id => l_request_id

Line 2034: ,p_status => IA_WF_UTIL_PKG.HeaderStatusRejected);

2030: p_calling_fn => callingProgram,
2031: p_parameter1 => debugInfo);
2032: -----------------------------------------------------
2033: Update_Request_Header_Status(p_request_id => l_request_id
2034: ,p_status => IA_WF_UTIL_PKG.HeaderStatusRejected);
2035:
2036: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2037: itemkey => itemkey,
2038: aname => 'REQUEST_STATUS',

Line 2036: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

2032: -----------------------------------------------------
2033: Update_Request_Header_Status(p_request_id => l_request_id
2034: ,p_status => IA_WF_UTIL_PKG.HeaderStatusRejected);
2035:
2036: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2037: itemkey => itemkey,
2038: aname => 'REQUEST_STATUS',
2039: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);
2040:

Line 2039: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);

2035:
2036: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2037: itemkey => itemkey,
2038: aname => 'REQUEST_STATUS',
2039: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);
2040:
2041: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2042: itemkey => itemkey,
2043: aname => 'REQUEST_STATUS_DISP',

Line 2041: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

2037: itemkey => itemkey,
2038: aname => 'REQUEST_STATUS',
2039: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);
2040:
2041: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2042: itemkey => itemkey,
2043: aname => 'REQUEST_STATUS_DISP',
2044: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2045: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));

Line 2044: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',

2040:
2041: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2042: itemkey => itemkey,
2043: aname => 'REQUEST_STATUS_DISP',
2044: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2045: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));
2046: -----------------------------------------------------
2047: debugInfo := 'Set the current detail status to Rejected';
2048: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

Line 2045: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));

2041: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2042: itemkey => itemkey,
2043: aname => 'REQUEST_STATUS_DISP',
2044: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2045: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));
2046: -----------------------------------------------------
2047: debugInfo := 'Set the current detail status to Rejected';
2048: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2049: p_calling_fn => callingProgram,

Line 2048: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2044: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2045: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));
2046: -----------------------------------------------------
2047: debugInfo := 'Set the current detail status to Rejected';
2048: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2049: p_calling_fn => callingProgram,
2050: p_parameter1 => debugInfo);
2051: -----------------------------------------------------
2052: Update_Request_Line_Status(p_request_id => l_request_id

Line 2053: ,p_status => IA_WF_UTIL_PKG.LineStatusRejected);

2049: p_calling_fn => callingProgram,
2050: p_parameter1 => debugInfo);
2051: -----------------------------------------------------
2052: Update_Request_Line_Status(p_request_id => l_request_id
2053: ,p_status => IA_WF_UTIL_PKG.LineStatusRejected);
2054:
2055: elsif (funcmode = 'CANCEL') THEN
2056:
2057: result := 'COMPLETE';

Line 2067: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

2063: FA_SRVR_MSG.add_message(
2064: calling_fn => callingProgram||':'||debugInfo);
2065: FA_SRVR_MSG.Add_SQL_Error(
2066: calling_fn => callingProgram);
2067: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2068: result := 'COMPLETE:ERROR';
2069:
2070: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2071: itemtype, itemkey, to_char(actid), debugInfo);

Line 2070: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

2066: calling_fn => callingProgram);
2067: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2068: result := 'COMPLETE:ERROR';
2069:
2070: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2071: itemtype, itemkey, to_char(actid), debugInfo);
2072: RAISE;
2073:
2074: END Process_Rejected;

Line 2104: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2100:
2101: if (funcmode = 'RUN') then
2102: -----------------------------------------------------
2103: debugInfo := 'Get request ID';
2104: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2105: p_calling_fn => callingProgram,
2106: p_parameter1 => debugInfo);
2107: -----------------------------------------------------
2108: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2119: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2115: ,aname => 'APPROVAL_CHAIN_PHASE');
2116:
2117: -----------------------------------------------------
2118: debugInfo := 'Get approval ID';
2119: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2120: p_calling_fn => callingProgram,
2121: p_parameter1 => debugInfo);
2122: -----------------------------------------------------
2123: l_approval_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2129: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2125: ,aname => 'APPROVAL_ID');
2126:
2127: -----------------------------------------------------
2128: debugInfo := 'Get approver ID';
2129: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2130: p_calling_fn => callingProgram,
2131: p_parameter1 => debugInfo);
2132: -----------------------------------------------------
2133: l_approver_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2144: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusRejected);

2140: debugInfo := 'Set the current approval status to Rejected';
2141: -----------------------------------------------------
2142: Update_Approval_Status(p_approval_id => l_approval_id
2143: ,p_chain_phase => l_chain_phase
2144: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusRejected);
2145:
2146: -----------------------------------------------------
2147: debugInfo := 'Set the current request status to Rejected';
2148: -----------------------------------------------------

Line 2150: ,p_status => IA_WF_UTIL_PKG.HeaderStatusRejected);

2146: -----------------------------------------------------
2147: debugInfo := 'Set the current request status to Rejected';
2148: -----------------------------------------------------
2149: Update_Request_Header_Status(p_request_id => l_request_id
2150: ,p_status => IA_WF_UTIL_PKG.HeaderStatusRejected);
2151:
2152: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2153: itemkey => itemkey,
2154: aname => 'REQUEST_STATUS',

Line 2152: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

2148: -----------------------------------------------------
2149: Update_Request_Header_Status(p_request_id => l_request_id
2150: ,p_status => IA_WF_UTIL_PKG.HeaderStatusRejected);
2151:
2152: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2153: itemkey => itemkey,
2154: aname => 'REQUEST_STATUS',
2155: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);
2156:

Line 2155: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);

2151:
2152: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2153: itemkey => itemkey,
2154: aname => 'REQUEST_STATUS',
2155: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);
2156:
2157: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2158: itemkey => itemkey,
2159: aname => 'REQUEST_STATUS_DISP',

Line 2157: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,

2153: itemkey => itemkey,
2154: aname => 'REQUEST_STATUS',
2155: avalue => IA_WF_UTIL_PKG.HeaderStatusRejected);
2156:
2157: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2158: itemkey => itemkey,
2159: aname => 'REQUEST_STATUS_DISP',
2160: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2161: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));

Line 2160: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',

2156:
2157: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2158: itemkey => itemkey,
2159: aname => 'REQUEST_STATUS_DISP',
2160: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2161: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));
2162: ****/
2163:
2164:

Line 2161: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));

2157: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
2158: itemkey => itemkey,
2159: aname => 'REQUEST_STATUS_DISP',
2160: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2161: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusRejected));
2162: ****/
2163:
2164:
2165: elsif (funcmode = 'CANCEL') THEN

Line 2177: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

2173: FA_SRVR_MSG.add_message(
2174: calling_fn => callingProgram||':'||debugInfo);
2175: FA_SRVR_MSG.Add_SQL_Error(
2176: calling_fn => callingProgram);
2177: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2178: result := 'COMPLETE:ERROR';
2179:
2180: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2181: itemtype, itemkey, to_char(actid), debugInfo);

Line 2180: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

2176: calling_fn => callingProgram);
2177: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2178: result := 'COMPLETE:ERROR';
2179:
2180: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2181: itemtype, itemkey, to_char(actid), debugInfo);
2182: RAISE;
2183:
2184: END Process_Cancelled;

Line 2212: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2208: if (funcmode = 'RUN') then
2209:
2210: -----------------------------------------------------
2211: debugInfo := 'Get request ID';
2212: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2213: p_calling_fn => callingProgram,
2214: p_parameter1 => debugInfo);
2215: -----------------------------------------------------
2216: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2222: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2218: ,aname => 'REQUEST_ID');
2219:
2220: -----------------------------------------------------
2221: debugInfo := 'Get approvals required flag';
2222: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2223: p_calling_fn => callingProgram,
2224: p_parameter1 => debugInfo);
2225: -----------------------------------------------------
2226: l_approvals_required := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2239: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2235: ,aname => 'APPROVAL_CHAIN_PHASE');
2236:
2237: -----------------------------------------------------
2238: debugInfo := 'Get approval ID';
2239: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2240: p_calling_fn => callingProgram,
2241: p_parameter1 => debugInfo);
2242: -----------------------------------------------------
2243: l_approval_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2249: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2245: ,aname => 'APPROVAL_ID');
2246:
2247: -----------------------------------------------------
2248: debugInfo := 'Update Approval Status to Finally Approved';
2249: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2250: p_calling_fn => callingProgram,
2251: p_parameter1 => debugInfo);
2252: -----------------------------------------------------
2253: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW

Line 2256: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusFinallyApproved);

2252: -----------------------------------------------------
2253: /* COMMENTED OUT DUE TO NEW STANDARD WORKFLOW
2254: Update_Approval_Status(p_approval_id => l_approval_id
2255: ,p_chain_phase => l_chain_phase
2256: ,p_approval_status => IA_WF_UTIL_PKG.ApprovalStatusFinallyApproved);
2257: */
2258: end if;
2259:
2260: -----------------------------------------------------

Line 2262: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2258: end if;
2259:
2260: -----------------------------------------------------
2261: debugInfo := 'Update Header Status to Approved';
2262: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2263: p_calling_fn => callingProgram,
2264: p_parameter1 => debugInfo);
2265: -----------------------------------------------------
2266: Update_Request_Header_Status(p_request_id => l_request_id

Line 2267: ,p_status => IA_WF_UTIL_PKG.HeaderStatusApproved);

2263: p_calling_fn => callingProgram,
2264: p_parameter1 => debugInfo);
2265: -----------------------------------------------------
2266: Update_Request_Header_Status(p_request_id => l_request_id
2267: ,p_status => IA_WF_UTIL_PKG.HeaderStatusApproved);
2268:
2269: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2270: itemkey => itemkey,
2271: aname => 'REQUEST_STATUS',

Line 2272: avalue => IA_WF_UTIL_PKG.HeaderStatusApproved);

2268:
2269: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2270: itemkey => itemkey,
2271: aname => 'REQUEST_STATUS',
2272: avalue => IA_WF_UTIL_PKG.HeaderStatusApproved);
2273:
2274: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2275: itemkey => itemkey,
2276: aname => 'REQUEST_STATUS_DISP',

Line 2277: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',

2273:
2274: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2275: itemkey => itemkey,
2276: aname => 'REQUEST_STATUS_DISP',
2277: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2278: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusApproved));
2279:
2280: result := 'COMPLETE:OK';
2281:

Line 2278: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusApproved));

2274: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2275: itemkey => itemkey,
2276: aname => 'REQUEST_STATUS_DISP',
2277: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2278: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusApproved));
2279:
2280: result := 'COMPLETE:OK';
2281:
2282: elsif (funcmode = 'CANCEL') THEN

Line 2294: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

2290: FA_SRVR_MSG.add_message(
2291: calling_fn => callingProgram||':'||debugInfo);
2292: FA_SRVR_MSG.Add_SQL_Error(
2293: calling_fn => callingProgram);
2294: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2295: result := 'COMPLETE:ERROR';
2296:
2297: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2298: itemtype, itemkey, to_char(actid), debugInfo);

Line 2297: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

2293: calling_fn => callingProgram);
2294: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2295: result := 'COMPLETE:ERROR';
2296:
2297: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2298: itemtype, itemkey, to_char(actid), debugInfo);
2299: RAISE;
2300:
2301: END Update_ApprovalStatus_To_Final;

Line 2330: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2326:
2327: if (funcmode = 'RUN') then
2328: -----------------------------------------------------
2329: debugInfo := 'Get approval ID';
2330: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2331: p_calling_fn => callingProgram,
2332: p_parameter1 => debugInfo);
2333: -----------------------------------------------------
2334: l_approval_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2340: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2336: ,aname => 'APPROVAL_ID');
2337:
2338: -----------------------------------------------------
2339: debugInfo := 'Get rule ID';
2340: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2341: p_calling_fn => callingProgram,
2342: p_parameter1 => debugInfo);
2343: -----------------------------------------------------
2344: l_rule_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2350: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2346: ,aname => 'RULE_ID');
2347:
2348: -----------------------------------------------------
2349: debugInfo := 'Get Book Type Code';
2350: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2351: p_calling_fn => callingProgram,
2352: p_parameter1 => debugInfo);
2353: -----------------------------------------------------
2354: l_book_type_code := WF_ENGINE.GetItemAttrText(itemtype => itemtype

Line 2360: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2356: ,aname => 'BOOK_TYPE_CODE');
2357:
2358: -----------------------------------------------------
2359: debugInfo := 'Check whether Super User approval is required';
2360: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2361: p_calling_fn => callingProgram,
2362: p_parameter1 => debugInfo);
2363: -----------------------------------------------------
2364: l_superuser_required := IA_WF_UTIL_PKG.IsSuperUserApprovalRequired(l_rule_id

Line 2364: l_superuser_required := IA_WF_UTIL_PKG.IsSuperUserApprovalRequired(l_rule_id

2360: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2361: p_calling_fn => callingProgram,
2362: p_parameter1 => debugInfo);
2363: -----------------------------------------------------
2364: l_superuser_required := IA_WF_UTIL_PKG.IsSuperUserApprovalRequired(l_rule_id
2365: ,l_book_type_code);
2366:
2367: result := 'COMPLETE:'||l_superuser_required;
2368:

Line 2381: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

2377: FA_SRVR_MSG.add_message(
2378: calling_fn => callingProgram||':'||debugInfo);
2379: FA_SRVR_MSG.Add_SQL_Error(
2380: calling_fn => callingProgram);
2381: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2382: result := 'COMPLETE:ERROR';
2383:
2384: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2385: itemtype, itemkey, to_char(actid), debugInfo);

Line 2384: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

2380: calling_fn => callingProgram);
2381: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2382: result := 'COMPLETE:ERROR';
2383:
2384: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2385: itemtype, itemkey, to_char(actid), debugInfo);
2386: RAISE;
2387:
2388: END SuperUser_Approval_Required;

Line 2411: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2407:
2408: if (funcmode = 'RUN') then
2409: -----------------------------------------------------
2410: debugInfo := 'Get request ID';
2411: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2412: p_calling_fn => callingProgram,
2413: p_parameter1 => debugInfo);
2414: -----------------------------------------------------
2415: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2421: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2417: ,aname => 'REQUEST_ID');
2418:
2419: -----------------------------------------------------
2420: debugInfo := 'Update request line status to ON_REVIEW';
2421: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2422: p_calling_fn => callingProgram,
2423: p_parameter1 => debugInfo);
2424: -----------------------------------------------------
2425: Update_Request_Line_Status(p_request_id => l_request_id

Line 2426: ,p_status => IA_WF_UTIL_PKG.LineStatusOnReview);

2422: p_calling_fn => callingProgram,
2423: p_parameter1 => debugInfo);
2424: -----------------------------------------------------
2425: Update_Request_Line_Status(p_request_id => l_request_id
2426: ,p_status => IA_WF_UTIL_PKG.LineStatusOnReview);
2427:
2428: elsif (funcmode = 'CANCEL') THEN
2429:
2430: result := 'COMPLETE';

Line 2440: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

2436: FA_SRVR_MSG.add_message(
2437: calling_fn => callingProgram||':'||debugInfo);
2438: FA_SRVR_MSG.Add_SQL_Error(
2439: calling_fn => callingProgram);
2440: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2441: result := 'COMPLETE:ERROR';
2442:
2443: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2444: itemtype, itemkey, to_char(actid), debugInfo);

Line 2443: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

2439: calling_fn => callingProgram);
2440: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2441: result := 'COMPLETE:ERROR';
2442:
2443: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2444: itemtype, itemkey, to_char(actid), debugInfo);
2445: RAISE;
2446:
2447: END Update_LineStatus_To_OnReview;

Line 2471: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2467: if (funcmode = 'RUN') then
2468:
2469: -----------------------------------------------------
2470: debugInfo := 'Get request ID';
2471: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2472: p_calling_fn => callingProgram,
2473: p_parameter1 => debugInfo);
2474: -----------------------------------------------------
2475: l_request_id := WF_ENGINE.GetItemAttrNumber(itemtype => itemtype

Line 2481: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2477: ,aname => 'REQUEST_ID');
2478:
2479: -----------------------------------------------------
2480: debugInfo := 'Update request line status to POST';
2481: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2482: p_calling_fn => callingProgram,
2483: p_parameter1 => debugInfo);
2484: -----------------------------------------------------
2485: Update_Request_Line_Status(p_request_id => l_request_id

Line 2486: ,p_status => IA_WF_UTIL_PKG.LineStatusPost);

2482: p_calling_fn => callingProgram,
2483: p_parameter1 => debugInfo);
2484: -----------------------------------------------------
2485: Update_Request_Line_Status(p_request_id => l_request_id
2486: ,p_status => IA_WF_UTIL_PKG.LineStatusPost);
2487:
2488:
2489: /*
2490: Added for Super User Feature

Line 2494: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,

2490: Added for Super User Feature
2491: */
2492: -----------------------------------------------------
2493: debugInfo := 'Update Header Status to Post';
2494: IA_WF_UTIL_PKG.AddWFDebugMessage(p_request_id => itemkey,
2495: p_calling_fn => callingProgram,
2496: p_parameter1 => debugInfo);
2497: -----------------------------------------------------
2498: Update_Request_Header_Status(p_request_id => l_request_id

Line 2499: ,p_status => IA_WF_UTIL_PKG.HeaderStatusPost);

2495: p_calling_fn => callingProgram,
2496: p_parameter1 => debugInfo);
2497: -----------------------------------------------------
2498: Update_Request_Header_Status(p_request_id => l_request_id
2499: ,p_status => IA_WF_UTIL_PKG.HeaderStatusPost);
2500:
2501: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2502: itemkey => itemkey,
2503: aname => 'REQUEST_STATUS',

Line 2504: avalue => IA_WF_UTIL_PKG.HeaderStatusPost);

2500:
2501: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2502: itemkey => itemkey,
2503: aname => 'REQUEST_STATUS',
2504: avalue => IA_WF_UTIL_PKG.HeaderStatusPost);
2505:
2506: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2507: itemkey => itemkey,
2508: aname => 'REQUEST_STATUS_DISP',

Line 2509: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',

2505:
2506: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2507: itemkey => itemkey,
2508: aname => 'REQUEST_STATUS_DISP',
2509: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2510: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusPost));
2511:
2512: result := 'COMPLETE:OK';
2513:

Line 2510: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusPost));

2506: WF_ENGINE.SetItemAttrText(itemtype => itemtype,
2507: itemkey => itemkey,
2508: aname => 'REQUEST_STATUS_DISP',
2509: avalue => IA_WF_UTIL_PKG.GetLookupMeaning(p_lookup_type=>'REQ_HDR_STATUS',
2510: p_lookup_code=>IA_WF_UTIL_PKG.HeaderStatusPost));
2511:
2512: result := 'COMPLETE:OK';
2513:
2514: elsif (funcmode = 'CANCEL') THEN

Line 2526: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');

2522: FA_SRVR_MSG.add_message(
2523: calling_fn => callingProgram||':'||debugInfo);
2524: FA_SRVR_MSG.Add_SQL_Error(
2525: calling_fn => callingProgram);
2526: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2527: result := 'COMPLETE:ERROR';
2528:
2529: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2530: itemtype, itemkey, to_char(actid), debugInfo);

Line 2529: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,

2525: calling_fn => callingProgram);
2526: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
2527: result := 'COMPLETE:ERROR';
2528:
2529: WF_CORE.Context(IA_WF_UTIL_PKG.WF_TransactionType, callingProgram,
2530: itemtype, itemkey, to_char(actid), debugInfo);
2531: RAISE;
2532:
2533: END Update_LineStatus_To_Post;