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_AME_REQUEST_PKG dependencies on IA_WF_UTIL_PKG

Line 42: IA_WF_UTIL_PKG.InitializeDebugMessage;

38: BEGIN
39:
40: -- initialize error message stack.
41: FA_SRVR_MSG.init_server_message;
42: IA_WF_UTIL_PKG.InitializeDebugMessage;
43:
44: -----------------------------------------------------
45: debugInfo := 'Validate the input values';
46: -----------------------------------------------------

Line 102: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

98: -----------------------------------------------------
99: debugInfo := 'Call AME_ENGIN.initializePlsqlContext to initialize';
100: -----------------------------------------------------
101: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
102: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
103: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_LOV_TransactionType,
104: transactionIdIn => newAmeLovId);
105:
106: *

Line 103: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_LOV_TransactionType,

99: debugInfo := 'Call AME_ENGIN.initializePlsqlContext to initialize';
100: -----------------------------------------------------
101: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
102: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
103: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_LOV_TransactionType,
104: transactionIdIn => newAmeLovId);
105:
106: *
107: * This step figures out what approval method to use based on the approval rule assigned to its responsibility.

Line 113: approvalMethod := IA_WF_UTIL_PKG.GetApprovalMethod(IA_WF_UTIL_PKG.GetRuleID,

109: -----------------------------------------------------
110: debugInfo := 'Determining what approval method to use';
111: -----------------------------------------------------
112:
113: approvalMethod := IA_WF_UTIL_PKG.GetApprovalMethod(IA_WF_UTIL_PKG.GetRuleID,
114: BookTypeCode);
115:
116: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, approvalMethod);
117:

Line 116: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, approvalMethod);

112:
113: approvalMethod := IA_WF_UTIL_PKG.GetApprovalMethod(IA_WF_UTIL_PKG.GetRuleID,
114: BookTypeCode);
115:
116: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, approvalMethod);
117:
118: -- approvalMethod := IA_WF_UTIL_PKG.ApprovalMethodHierarchy; -- DEBUG !!
119:
120: *

Line 118: -- approvalMethod := IA_WF_UTIL_PKG.ApprovalMethodHierarchy; -- DEBUG !!

114: BookTypeCode);
115:
116: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, approvalMethod);
117:
118: -- approvalMethod := IA_WF_UTIL_PKG.ApprovalMethodHierarchy; -- DEBUG !!
119:
120: *
121: * Being based on the approval method, the AME LOV API will then determine which AME approval group to use
122: *

Line 127: if (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodHierarchy) then

123: -----------------------------------------------------
124: debugInfo := 'Get corresponding approval group ID';
125: -----------------------------------------------------
126: -- Call Management-hierarchy based approval group
127: if (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodHierarchy) then
128:
129: if (LOVType = IA_WF_UTIL_PKG.LOVTypeReleasing) then
130: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRelGroup);
131: elsif (LOVType = IA_WF_UTIL_PKG.LOVTypeDestination) then

Line 129: if (LOVType = IA_WF_UTIL_PKG.LOVTypeReleasing) then

125: -----------------------------------------------------
126: -- Call Management-hierarchy based approval group
127: if (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodHierarchy) then
128:
129: if (LOVType = IA_WF_UTIL_PKG.LOVTypeReleasing) then
130: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRelGroup);
131: elsif (LOVType = IA_WF_UTIL_PKG.LOVTypeDestination) then
132: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRecGroup);
133: end if;

Line 130: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRelGroup);

126: -- Call Management-hierarchy based approval group
127: if (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodHierarchy) then
128:
129: if (LOVType = IA_WF_UTIL_PKG.LOVTypeReleasing) then
130: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRelGroup);
131: elsif (LOVType = IA_WF_UTIL_PKG.LOVTypeDestination) then
132: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRecGroup);
133: end if;
134:

Line 131: elsif (LOVType = IA_WF_UTIL_PKG.LOVTypeDestination) then

127: if (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodHierarchy) then
128:
129: if (LOVType = IA_WF_UTIL_PKG.LOVTypeReleasing) then
130: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRelGroup);
131: elsif (LOVType = IA_WF_UTIL_PKG.LOVTypeDestination) then
132: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRecGroup);
133: end if;
134:
135: elsif (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodCostCenter) then

Line 132: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRecGroup);

128:
129: if (LOVType = IA_WF_UTIL_PKG.LOVTypeReleasing) then
130: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRelGroup);
131: elsif (LOVType = IA_WF_UTIL_PKG.LOVTypeDestination) then
132: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRecGroup);
133: end if;
134:
135: elsif (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodCostCenter) then
136: -- Call Cost-center based approval group

Line 135: elsif (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodCostCenter) then

131: elsif (LOVType = IA_WF_UTIL_PKG.LOVTypeDestination) then
132: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.HierarchyBasedRecGroup);
133: end if;
134:
135: elsif (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodCostCenter) then
136: -- Call Cost-center based approval group
137: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.CostCenterBasedGroup);
138:
139: else

Line 137: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.CostCenterBasedGroup);

133: end if;
134:
135: elsif (approvalMethod = IA_WF_UTIL_PKG.ApprovalMethodCostCenter) then
136: -- Call Cost-center based approval group
137: approvalGroupId := AME_APPROVAL_GROUP_PKG.getId(nameIn=>IA_WF_UTIL_PKG.CostCenterBasedGroup);
138:
139: else
140:
141: raise localException;

Line 145: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, approvalGroupId);

141: raise localException;
142:
143: end if;
144:
145: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, approvalGroupId);
146:
147: approverTypesList := AME_UTIL.emptyStringList;
148: approverIdsList := AME_UTIL.emptyStringList;
149:

Line 153: if (approvalMethod in (IA_WF_UTIL_PKG.ApprovalMethodHierarchy

149:
150: -----------------------------------------------------
151: debugInfo := 'Call corresponding approval group';
152: -----------------------------------------------------
153: if (approvalMethod in (IA_WF_UTIL_PKG.ApprovalMethodHierarchy
154: ,IA_WF_UTIL_PKG.ApprovalMethodCostCenter) ) then
155:
156: AME_APPROVAL_GROUP_PKG.getRuntimeGroupMembers(groupIdIn => approvalGroupId,
157: parameterNamesOut => approverTypesList,

Line 154: ,IA_WF_UTIL_PKG.ApprovalMethodCostCenter) ) then

150: -----------------------------------------------------
151: debugInfo := 'Call corresponding approval group';
152: -----------------------------------------------------
153: if (approvalMethod in (IA_WF_UTIL_PKG.ApprovalMethodHierarchy
154: ,IA_WF_UTIL_PKG.ApprovalMethodCostCenter) ) then
155:
156: AME_APPROVAL_GROUP_PKG.getRuntimeGroupMembers(groupIdIn => approvalGroupId,
157: parameterNamesOut => approverTypesList,
158: parametersOut => approverIdsList);

Line 163: if (IA_WF_UTIL_PKG.DebugModeEnabled) then

159:
160: ApproverTypesTable := approverTypesList;
161: ApproverIdsTable := approverIdsList;
162:
163: if (IA_WF_UTIL_PKG.DebugModeEnabled) then
164:
165: if (approverIdsList.count > 0) then
166:
167: -----------------------------------------------------------------------

Line 170: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'approverIdsList', debugInfo);

166:
167: -----------------------------------------------------------------------
168: debugInfo := 'Number of Managers: ' || approverIdsList.count;
169: -----------------------------------------------------------------------
170: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'approverIdsList', debugInfo);
171:
172: for i in 1 .. approverIdsList.count loop
173:
174: -----------------------------------------------------------------------

Line 177: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'approverIdsList', debugInfo);

173:
174: -----------------------------------------------------------------------
175: debugInfo := 'Managers(' || i || ').type = ' || approverTypesList(i);
176: -----------------------------------------------------------------------
177: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'approverIdsList', debugInfo);
178:
179: -----------------------------------------------------------------------
180: debugInfo := 'Managers(' || i || ').person_id = ' || approverIdsList(i);
181: -----------------------------------------------------------------------

Line 182: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'approverIdsList', debugInfo);

178:
179: -----------------------------------------------------------------------
180: debugInfo := 'Managers(' || i || ').person_id = ' || approverIdsList(i);
181: -----------------------------------------------------------------------
182: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'approverIdsList', debugInfo);
183:
184: end loop;
185:
186: end if; -- if (approverIdsList.count > 0)

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

199: FA_SRVR_MSG.add_message(
200: calling_fn => callingProgram||':'||debugInfo);
201: FA_SRVR_MSG.Add_SQL_Error(
202: calling_fn => callingProgram);
203: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, debugInfo, 'Error');
204:
205: return FALSE;
206:
207: END GetLOVApprovers;

Line 233: -- IA_WF_UTIL_PKG.InitializeDebugMessage;

229: BEGIN
230:
231: -- initialize error message stack.
232: -- FA_SRVR_MSG.init_server_message;
233: -- IA_WF_UTIL_PKG.InitializeDebugMessage;
234:
235: *
236: * This step calls AME_API.getNextApprover.
237: *

Line 241: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);

237: *
238: -----------------------------------------------------
239: debugInfo := 'Calling AME_API.getNextApprover(RequestId, Approver)';
240: -----------------------------------------------------
241: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
242:
243: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
244: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
245: transactionIdIn => RequestId,

Line 243: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

239: debugInfo := 'Calling AME_API.getNextApprover(RequestId, Approver)';
240: -----------------------------------------------------
241: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
242:
243: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
244: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
245: transactionIdIn => RequestId,
246: nextApproverOut => approverRecord);
247:

Line 244: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,

240: -----------------------------------------------------
241: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
242:
243: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
244: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
245: transactionIdIn => RequestId,
246: nextApproverOut => approverRecord);
247:
248: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);

Line 248: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);

244: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
245: transactionIdIn => RequestId,
246: nextApproverOut => approverRecord);
247:
248: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);
249:
250: Approver := approverRecord;
251:
252: return TRUE;

Line 300: -- IA_WF_UTIL_PKG.InitializeDebugMessage;

296: BEGIN
297:
298: -- initialize error message stack.
299: -- FA_SRVR_MSG.init_server_message;
300: -- IA_WF_UTIL_PKG.InitializeDebugMessage;
301:
302: l_chainPhase := ChainPhase;
303: NoMoreApproverFlag := 'N';
304:

Line 339: and application_id=IA_WF_UTIL_PKG.GetApplicationID;

335: select responsibility_id
336: into l_dummy
337: from fnd_responsibility
338: where responsibility_id=l_responsibility_id
339: and application_id=IA_WF_UTIL_PKG.GetApplicationID;
340:
341: exception
342: when others then
343: FND_MESSAGE.set_name('IA', 'IA_NO_RESPONSIBILITY_FOUND'); -- Error: Unable to find responsibility id, RESPONSIBILITY_ID

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

350: debugInfo := 'Get Rule ID';
351: -----------------------------------------------------
352: begin
353:
354: l_rule_id := IA_WF_UTIL_PKG.GetRuleID(p_responsibility_id => l_responsibility_id);
355:
356: exception
357: when others then
358: FND_MESSAGE.set_name('IA', 'IA_NO_RULE_ASSIGNED');

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

364:
365: -----------------------------------------------------
366: debugInfo := 'Initialize rule setup';
367: -----------------------------------------------------
368: if (not IA_WF_UTIL_PKG.ResetRuleSetup(p_rule_id => l_rule_id,
369: p_book_type_code => l_book_type_code) ) then
370: FND_MESSAGE.set_name('IA', 'IA_RULE_RETRIEVAL_ERROR'); -- Error: Unable to find rule id, RULE_ID
371: FND_MESSAGE.set_token('RULE_ID', l_rule_id);
372: l_error_message := FND_MESSAGE.Get;

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

375:
376: -----------------------------------------------------
377: debugInfo := 'Get Approval Type';
378: -----------------------------------------------------
379: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id,
380: p_book_type_code => l_book_type_code);
381:
382: -----------------------------------------------------
383: debugInfo := 'Get Approval Method';

Line 385: l_approval_method := IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => l_rule_id,

381:
382: -----------------------------------------------------
383: debugInfo := 'Get Approval Method';
384: -----------------------------------------------------
385: l_approval_method := IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => l_rule_id,
386: p_book_type_code => l_book_type_code);
387:
388:
389: if ( l_approval_method = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then

Line 389: if ( l_approval_method = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then

385: l_approval_method := IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => l_rule_id,
386: p_book_type_code => l_book_type_code);
387:
388:
389: if ( l_approval_method = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then
390:
391: /*
392: * This step calls AME_API.getNextApprover.
393: */

Line 397: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);

393: */
394: -----------------------------------------------------
395: debugInfo := 'Calling AME_API.getNextApprover(long format)';
396: -----------------------------------------------------
397: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
398:
399:
400: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
401:

Line 400: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then

396: -----------------------------------------------------
397: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
398:
399:
400: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
401:
402: -----------------------------------------------------
403: debugInfo := 'Calling AME_API.getNextApprover for releasing chain';
404: -----------------------------------------------------

Line 405: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

401:
402: -----------------------------------------------------
403: debugInfo := 'Calling AME_API.getNextApprover for releasing chain';
404: -----------------------------------------------------
405: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
406: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
407: transactionIdIn => RequestId,
408: nextApproverOut => approverRecord);
409:

Line 406: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,

402: -----------------------------------------------------
403: debugInfo := 'Calling AME_API.getNextApprover for releasing chain';
404: -----------------------------------------------------
405: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
406: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
407: transactionIdIn => RequestId,
408: nextApproverOut => approverRecord);
409:
410: if (approverRecord.person_id is NULL) then

Line 411: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

407: transactionIdIn => RequestId,
408: nextApproverOut => approverRecord);
409:
410: if (approverRecord.person_id is NULL) then
411: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
412: end if;
413:
414: end if;
415:

Line 416: if (l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeDestination) then

412: end if;
413:
414: end if;
415:
416: if (l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
417:
418: -----------------------------------------------------
419: debugInfo := 'Calling AME_API.getNextApprover for receiving chain';
420: -----------------------------------------------------

Line 421: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

417:
418: -----------------------------------------------------
419: debugInfo := 'Calling AME_API.getNextApprover for receiving chain';
420: -----------------------------------------------------
421: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
422: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
423: transactionIdIn => RequestId,
424: nextApproverOut => approverRecord);
425:

Line 422: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,

418: -----------------------------------------------------
419: debugInfo := 'Calling AME_API.getNextApprover for receiving chain';
420: -----------------------------------------------------
421: AME_API.getNextApprover(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
422: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
423: transactionIdIn => RequestId,
424: nextApproverOut => approverRecord);
425:
426: if (approverRecord.person_id is NULL) then

Line 436: NoMoreApproverFlag := WF_ENGINE.GetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType

432: else
433:
434: -- The following logic will be executed when approval method is COST_CENTER.
435:
436: NoMoreApproverFlag := WF_ENGINE.GetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType
437: ,itemkey => RequestId
438: ,aname => 'NO_MORE_APPROVER_FLAG');
439:
440: -- if (NoMoreApproverFlag is null or NoMoreApproverFlag = 'N') then

Line 441: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing ) then

437: ,itemkey => RequestId
438: ,aname => 'NO_MORE_APPROVER_FLAG');
439:
440: -- if (NoMoreApproverFlag is null or NoMoreApproverFlag = 'N') then
441: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing ) then
442:
443: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or
444: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
445:

Line 443: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or

439:
440: -- if (NoMoreApproverFlag is null or NoMoreApproverFlag = 'N') then
441: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing ) then
442:
443: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or
444: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
445:
446: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
447: approverRecord.person_id := l_releasing_approver_id;

Line 444: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then

440: -- if (NoMoreApproverFlag is null or NoMoreApproverFlag = 'N') then
441: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing ) then
442:
443: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or
444: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
445:
446: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
447: approverRecord.person_id := l_releasing_approver_id;
448: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

Line 446: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then

442:
443: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or
444: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
445:
446: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
447: approverRecord.person_id := l_releasing_approver_id;
448: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
449: end if;
450:

Line 448: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

444: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
445:
446: if (l_chainPhase is NULL or l_chainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
447: approverRecord.person_id := l_releasing_approver_id;
448: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
449: end if;
450:
451: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
452: NoMoreApproverFlag := 'Y';

Line 451: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then

447: approverRecord.person_id := l_releasing_approver_id;
448: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
449: end if;
450:
451: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
452: NoMoreApproverFlag := 'Y';
453: else
454: NoMoreApproverFlag := 'S';
455: end if;

Line 462: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

458:
459: elsif (NoMoreApproverFlag='Y') then
460:
461: approverRecord.person_id := null;
462: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
463: NoMoreApproverFlag := 'Y';
464:
465: else
466:

Line 467: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or

463: NoMoreApproverFlag := 'Y';
464:
465: else
466:
467: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or
468: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
469:
470: approverRecord.person_id := l_receiving_approver_id;
471: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

Line 468: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then

464:
465: else
466:
467: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or
468: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
469:
470: approverRecord.person_id := l_receiving_approver_id;
471: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
472: NoMoreApproverFlag := 'Y';

Line 471: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;

467: if (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or
468: l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination) then
469:
470: approverRecord.person_id := l_receiving_approver_id;
471: l_chainPhase := IA_WF_UTIL_PKG.ApprovalTypeDestination;
472: NoMoreApproverFlag := 'Y';
473:
474: end if;
475:

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

474: end if;
475:
476: end if;
477:
478: WF_ENGINE.SetItemAttrText(itemtype => IA_WF_UTIL_PKG.WF_TransactionType,
479: itemkey => RequestId,
480: aname => 'NO_MORE_APPROVER_FLAG',
481: avalue => NoMoreApproverFlag);
482:

Line 489: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);

485: -- return out parameters
486: ChainPhase := l_chainPhase;
487: Approver := approverRecord;
488:
489: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);
490:
491:
492: return TRUE;
493:

Line 570: and application_id=IA_WF_UTIL_PKG.GetApplicationID;

566: select responsibility_id
567: into l_dummy
568: from fnd_responsibility
569: where responsibility_id=l_responsibility_id
570: and application_id=IA_WF_UTIL_PKG.GetApplicationID;
571:
572: exception
573: when others then
574: FND_MESSAGE.set_name('IA', 'IA_NO_RESPONSIBILITY_FOUND'); -- Error: Unable to find responsibility id, RESPONSIBILITY_ID

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

581: debugInfo := 'Get Rule ID';
582: -----------------------------------------------------
583: begin
584:
585: l_rule_id := IA_WF_UTIL_PKG.GetRuleID(p_responsibility_id => l_responsibility_id);
586:
587: exception
588: when others then
589: FND_MESSAGE.set_name('IA', 'IA_NO_RULE_ASSIGNED'); -- Error: No rule has been defined for responsibility id, RESPONSIBILITY_ID.

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

594:
595: -----------------------------------------------------
596: debugInfo := 'Initialize rule setup';
597: -----------------------------------------------------
598: if (not IA_WF_UTIL_PKG.ResetRuleSetup(p_rule_id => l_rule_id,
599: p_book_type_code => l_book_type_code) ) then
600: FND_MESSAGE.set_name('IA', 'IA_RULE_RETRIEVAL_ERROR'); -- Error: Unable to find rule id, RULE_ID
601: FND_MESSAGE.set_token('RULE_ID', l_rule_id);
602: l_error_message := FND_MESSAGE.Get;

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

605:
606: -----------------------------------------------------
607: debugInfo := 'Get Approval Type';
608: -----------------------------------------------------
609: l_approval_type := IA_WF_UTIL_PKG.GetApprovalType(p_rule_id => l_rule_id,
610: p_book_type_code => l_book_type_code);
611:
612: -----------------------------------------------------
613: debugInfo := 'Get Approval Method';

Line 615: l_approval_method := IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => l_rule_id,

611:
612: -----------------------------------------------------
613: debugInfo := 'Get Approval Method';
614: -----------------------------------------------------
615: l_approval_method := IA_WF_UTIL_PKG.GetApprovalMethod(p_rule_id => l_rule_id,
616: p_book_type_code => l_book_type_code);
617:
618:
619: /*

Line 623: -- if ( l_approval_method = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then

619: /*
620: * This step calls AME_API.getAllApprovers only when Approval method is HIERARCHY.
621: */
622:
623: -- if ( l_approval_method = IA_WF_UTIL_PKG.ApprovalMethodHierarchy ) then
624:
625: -----------------------------------------------------
626: debugInfo := 'Calling AME_API.getAllApprovers';
627: -----------------------------------------------------

Line 628: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);

624:
625: -----------------------------------------------------
626: debugInfo := 'Calling AME_API.getAllApprovers';
627: -----------------------------------------------------
628: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
629:
630: if (l_releasing_approver_id is NOT NULL
631: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing)) then
632: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

Line 631: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing)) then

627: -----------------------------------------------------
628: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
629:
630: if (l_releasing_approver_id is NOT NULL
631: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing)) then
632: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
633: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
634: transactionIdIn => RequestId,
635: ApproversOut => ReleasingApprovers);

Line 632: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

628: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
629:
630: if (l_releasing_approver_id is NOT NULL
631: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing)) then
632: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
633: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
634: transactionIdIn => RequestId,
635: ApproversOut => ReleasingApprovers);
636: end if;

Line 633: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,

629:
630: if (l_releasing_approver_id is NOT NULL
631: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeReleasing)) then
632: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
633: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
634: transactionIdIn => RequestId,
635: ApproversOut => ReleasingApprovers);
636: end if;
637:

Line 639: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination)) then

635: ApproversOut => ReleasingApprovers);
636: end if;
637:
638: if (l_receiving_approver_id is NOT NULL
639: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination)) then
640: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
641: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
642: transactionIdIn => RequestId,
643: ApproversOut => ReceivingApprovers);

Line 640: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

636: end if;
637:
638: if (l_receiving_approver_id is NOT NULL
639: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination)) then
640: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
641: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
642: transactionIdIn => RequestId,
643: ApproversOut => ReceivingApprovers);
644: end if;

Line 641: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,

637:
638: if (l_receiving_approver_id is NOT NULL
639: and (l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeAll or l_approval_type = IA_WF_UTIL_PKG.ApprovalTypeDestination)) then
640: AME_API.getAllApprovers(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
641: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
642: transactionIdIn => RequestId,
643: ApproversOut => ReceivingApprovers);
644: end if;
645:

Line 646: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);

642: transactionIdIn => RequestId,
643: ApproversOut => ReceivingApprovers);
644: end if;
645:
646: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);
647:
648: /*
649: else
650:

Line 685: l_transactionType VARCHAR2(255) := IA_WF_UTIL_PKG.AME_RELEASE_TransactionType;

681: Forwardee IN AME_UTIL.approverRecord DEFAULT AME_UTIL.emptyApproverRecord)
682: return BOOLEAN
683: IS
684:
685: l_transactionType VARCHAR2(255) := IA_WF_UTIL_PKG.AME_RELEASE_TransactionType;
686:
687: debugInfo VARCHAR2(255) := NULL;
688:
689: localException EXCEPTION;

Line 701: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);

697: */
698: -----------------------------------------------------
699: debugInfo := 'Calling AME_API.UpdateApprovalStatus';
700: -----------------------------------------------------
701: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
702:
703: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
704: l_transactionType := IA_WF_UTIL_PKG.AME_RELEASE_TransactionType;
705: else

Line 703: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then

699: debugInfo := 'Calling AME_API.UpdateApprovalStatus';
700: -----------------------------------------------------
701: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
702:
703: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
704: l_transactionType := IA_WF_UTIL_PKG.AME_RELEASE_TransactionType;
705: else
706: l_transactionType := IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType;
707: end if;

Line 704: l_transactionType := IA_WF_UTIL_PKG.AME_RELEASE_TransactionType;

700: -----------------------------------------------------
701: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
702:
703: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
704: l_transactionType := IA_WF_UTIL_PKG.AME_RELEASE_TransactionType;
705: else
706: l_transactionType := IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType;
707: end if;
708:

Line 706: l_transactionType := IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType;

702:
703: if (ChainPhase = IA_WF_UTIL_PKG.ApprovalTypeReleasing) then
704: l_transactionType := IA_WF_UTIL_PKG.AME_RELEASE_TransactionType;
705: else
706: l_transactionType := IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType;
707: end if;
708:
709: AME_API.updateApprovalStatus(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
710: transactionTypeIn => l_transactionType,

Line 709: AME_API.updateApprovalStatus(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

705: else
706: l_transactionType := IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType;
707: end if;
708:
709: AME_API.updateApprovalStatus(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
710: transactionTypeIn => l_transactionType,
711: transactionIdIn => RequestId,
712: approverIn => Approver,
713: forwardeeIn => Forwardee);

Line 716: AME_API.updateApprovalStatus2(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

712: approverIn => Approver,
713: forwardeeIn => Forwardee);
714:
715: /*
716: AME_API.updateApprovalStatus2(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
717: transactionIdIn => l_transactionType,
718: approvalStatusIn => ame_util.noResponseStatus,
719: approverPersonIdIn => l_forward_from_id,
720: approverUserIdIn => NULL,

Line 725: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);

721: transactionTypeIn => p_item_type,
722: forwardeeIn => l_recApprover);
723: */
724:
725: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'after', debugInfo);
726:
727: return TRUE;
728:
729: EXCEPTION

Line 758: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);

754: */
755: -----------------------------------------------------
756: debugInfo := 'Calling AME_ENGINE.initializePlsqlContext';
757: -----------------------------------------------------
758: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
759:
760: /*
761: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
762: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

Line 762: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

758: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
759:
760: /*
761: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
762: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
763: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
764: transactionIdIn => RequestId);
765:
766: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,

Line 763: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,

759:
760: /*
761: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
762: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
763: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
764: transactionIdIn => RequestId);
765:
766: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
767: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

Line 767: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

763: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
764: transactionIdIn => RequestId);
765:
766: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
767: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
768: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
769: transactionIdIn => RequestId);
770: */
771:

Line 768: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,

764: transactionIdIn => RequestId);
765:
766: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
767: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
768: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
769: transactionIdIn => RequestId);
770: */
771:
772: return TRUE;

Line 803: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);

799: */
800: -----------------------------------------------------
801: debugInfo := 'Calling AME_ENGINE.initializePlsqlContext';
802: -----------------------------------------------------
803: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
804:
805: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
806: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
807: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,

Line 806: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

802: -----------------------------------------------------
803: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
804:
805: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
806: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
807: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
808: transactionIdIn => RequestId);
809:
810: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,

Line 807: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,

803: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
804:
805: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
806: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
807: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
808: transactionIdIn => RequestId);
809:
810: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
811: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

Line 811: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

807: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
808: transactionIdIn => RequestId);
809:
810: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
811: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
812: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
813: transactionIdIn => RequestId);
814:
815: -----------------------------------------------------

Line 812: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,

808: transactionIdIn => RequestId);
809:
810: AME_ENGINE.initializePlsqlContext(ameApplicationIdIn => null,
811: fndApplicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
812: transactionTypeIdIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
813: transactionIdIn => RequestId);
814:
815: -----------------------------------------------------
816: debugInfo := 'Calling AME_API.clearAllApprovals';

Line 818: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);

814:
815: -----------------------------------------------------
816: debugInfo := 'Calling AME_API.clearAllApprovals';
817: -----------------------------------------------------
818: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
819:
820: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
821: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
822: transactionIdIn => RequestId);

Line 820: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

816: debugInfo := 'Calling AME_API.clearAllApprovals';
817: -----------------------------------------------------
818: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
819:
820: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
821: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
822: transactionIdIn => RequestId);
823:
824: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

Line 821: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,

817: -----------------------------------------------------
818: IA_WF_UTIL_PKG.AddDebugMessage(callingProgram, 'before', debugInfo);
819:
820: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
821: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
822: transactionIdIn => RequestId);
823:
824: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
825: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,

Line 824: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,

820: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
821: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
822: transactionIdIn => RequestId);
823:
824: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
825: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
826: transactionIdIn => RequestId);
827:
828:

Line 825: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,

821: transactionTypeIn => IA_WF_UTIL_PKG.AME_RELEASE_TransactionType,
822: transactionIdIn => RequestId);
823:
824: AME_API.clearAllApprovals(applicationIdIn => IA_WF_UTIL_PKG.GetApplicationID,
825: transactionTypeIn => IA_WF_UTIL_PKG.AME_RECEIVE_TransactionType,
826: transactionIdIn => RequestId);
827:
828:
829: return TRUE;