1 package ame_api as
2 /* $Header: ameeapin.pkh 120.3.12000000.1 2007/01/17 23:49:29 appldev noship $ */
3 /*#
4 * This package contains APIs that a typical workflow uses to process an
5 * approval.
6 * @rep:scope public
7 * @rep:product AME
8 * @rep:displayname Approval Process
9 */
10 --
11 -- ----------------------------------------------------------------------------
12 -- |----------------------------< getruledescription >------------------------|
13 -- ----------------------------------------------------------------------------
14 --
15 -- {Start Of Comments}
16 /*#
17 * This API returns the description of a given rule.
18 *
19 * Rule descriptions are at most 100 bytes long. Note : This API is an
20 * alternative API for ame_api3.getRuleDescription.
21 *
22 * <p><b>Licensing</b><br>
23 * This API is available for use with any licensed component of the e-business
24 * suite.
25 *
26 * <p><b>Prerequisites</b><br>
27 * No known prerequisites.
28 *
29 * <p><b>Post Success</b><br>
30 * The API will return the rule description.
31 *
32 * <p><b>Post Failure</b><br>
33 * The API will raise an error.
34 *
35 * @param ruleidin Rule id
36 * @return The API will return the rule description for the input rule id.
37 * @rep:displayname Get Rule Description
38 * @rep:category BUSINESS_ENTITY AME_APPROVAL
39 * @rep:lifecycle active
40 * @rep:scope public
41 */
42 --
43 -- {End Of Comments}
44 --
45 function getRuleDescription(ruleIdIn in varchar2) return varchar2;
46 --
47 -- ----------------------------------------------------------------------------
48 -- |-----------------------------< validateapprover >-------------------------|
49 -- ----------------------------------------------------------------------------
50 --
51 -- {Start Of Comments}
52 /*#
53 * This API validates an approver.
54 *
55 * This API checks if the specified approver is valid by looking at WF Roles.
56 *
57 * <p><b>Licensing</b><br>
58 * This API is available for use with any licensed component of the e-business
59 * suite.
60 *
61 * <p><b>Prerequisites</b><br>
62 * No known prerequisites.
63 *
64 * <p><b>Post Success</b><br>
65 * This API will return true if the approver represented by approverIn has a
66 * current wf_roles entry, otherwise will return false.
67 *
68 * <p><b>Post Failure</b><br>
69 * This API returns false.
70 *
71 * @param approverin This is an ame_util.approverRecord that represents an
72 * approver.
73 * @return This API will return true if the approver represented by approverIn has a current wf_roles entry, otherwise will return false.
74 * @rep:displayname Validate Approver
75 * @rep:category BUSINESS_ENTITY AME_APPROVAL
76 * @rep:lifecycle active
77 * @rep:scope public
78 */
79 --
80 -- {End Of Comments}
81 --
82 function validateApprover(approverIn in ame_util.approverRecord) return boolean;
83 --
84 -- ----------------------------------------------------------------------------
85 -- |-----------------------------< clearallapprovals >-------------------------|
86 -- ----------------------------------------------------------------------------
87 --
88 -- {Start Of Comments}
89 /*#
90 * This API clears the approval process of a transaction.
91 *
92 * This restores the default approver list (removing
93 * approver insertions, suppressions, forwardings, etc.). Use this
94 * API to restart a transaction's approval process from scratch,
95 * undoing any operations that have already modified the approval
96 * process.
97 *
98 * <p><b>Licensing</b><br>
99 * This API is available for use with any licensed component of the e-business
100 * suite.
101 *
102 * <p><b>Prerequisites</b><br>
103 * No known prerequisites.
104 *
105 * <p><b>Post Success</b><br>
106 * The approval process of the given transaction will be cleared.
107 *
108 * <p><b>Post Failure</b><br>
109 * The API will raise an error.
110 *
111 * @param applicationidin The fnd_application.application_id value of the
112 * originating application calling the AME API routine.
113 * @param transactionidin This is a string up to 50 bytes long. It identifies a
114 * transaction within a transaction type. Its value must not contain
115 * white-space characters, and must not be the character representation of a
116 * negative integer.
117 * @param transactiontypein This is a string parameter up to 50 bytes long. It
118 * distinguishes one transaction type from another, within a given originating
119 * application. It can be null, but you must always pass its value explicitly.
120 * @rep:displayname Clear All Approvals
121 * @rep:category BUSINESS_ENTITY AME_APPROVAL
122 * @rep:lifecycle active
123 * @rep:scope public
124 */
125 --
126 -- {End Of Comments}
127 --
128 procedure clearAllApprovals(applicationIdIn in integer,
129 transactionIdIn in varchar2,
130 transactionTypeIn in varchar2 default null);
131 --
132 -- ----------------------------------------------------------------------------
133 -- |-----------------------------< cleardeletion >-------------------------|
134 -- ----------------------------------------------------------------------------
135 --
136 -- {Start Of Comments}
137 /*#
138 * This API clears a deletion of an approver, genereated by a rule,
139 * previously requested via the deleteApprover or deleteApprovers API.
140 * Typical use: Reverse a delete approver instruction
141 *
142 * <p><b>Licensing</b><br>
143 * This API is available for use with any licensed component of the e-business
144 * suite.
145 *
146 * <p><b>Prerequisites</b><br>
147 * The approver must have been deleted via the deleteApprover or deleteApprovers API.
148 *
149 * <p><b>Post Success</b><br>
150 * The deletion of the approver will be cleared.
151 *
152 * <p><b>Post Failure</b><br>
153 * The API will raise an error.
154 *
155 * @param approverIn This is the approver record defined by
156 * ame_util.approverRecord which identifies the Approver.
157 * @param applicationidin The fnd_application.application_id value of the
158 * originating application calling the AME API routine.
159 * @param transactionidin This is a string up to 50 bytes long. It identifies a
160 * transaction within a transaction type. Its value must not contain
161 * white-space characters, and must not be the character representation of a
162 * negative integer.
163 * @param transactiontypein This is a string parameter up to 50 bytes long. It
164 * distinguishes one transaction type from another, within a given originating
165 * application. It can be null, but you must always pass its value explicitly.
166 * @rep:displayname Clear Deletion
167 * @rep:category BUSINESS_ENTITY AME_APPROVAL
168 * @rep:lifecycle active
169 * @rep:scope public
170 */
171 --
172 -- {End Of Comments}
173 --
174 procedure clearDeletion(approverIn in ame_util.approverRecord,
175 applicationIdIn in integer,
176 transactionIdIn in varchar2,
177 transactionTypeIn in varchar2 default null);
178 --
179 -- ----------------------------------------------------------------------------
180 -- |-----------------------------< cleardeletions >-------------------------|
181 -- ----------------------------------------------------------------------------
182 --
183 -- {Start Of Comments}
184 /*#
185 * This API clears all the deletions requested previously for a
186 * given transaction. This is same as the clearDeletion API but in this case it
187 * clears all the deletions for the specified transaction.
188 *
189 * <p><b>Licensing</b><br>
190 * This API is available for use with any licensed component of the e-business
191 * suite.
192 *
193 * <p><b>Prerequisites</b><br>
194 * No known prerequisites.
195 *
196 * <p><b>Post Success</b><br>
197 * All the previously requested deletions for the given transaction will be cleared.
198 *
199 * <p><b>Post Failure</b><br>
200 * The API will raise an error.
201 *
202 * @param applicationidin The fnd_application.application_id value of the
203 * originating application calling the AME API routine.
204 * @param transactionidin This is a string up to 50 bytes long. It identifies a
205 * transaction within a transaction type. Its value must not contain
206 * white-space characters, and must not be the character representation of a
207 * negative integer.
208 * @param transactiontypein This is a string parameter up to 50 bytes long. It
209 * distinguishes one transaction type from another, within a given originating
210 * application. It can be null, but you must always pass its value explicitly.
211 * @rep:displayname Clear Deletions
212 * @rep:category BUSINESS_ENTITY AME_APPROVAL
213 * @rep:lifecycle active
214 * @rep:scope public
215 */
216 --
217 -- {End Of Comments}
218 --
219 procedure clearDeletions(applicationIdIn in integer,
220 transactionIdIn in varchar2,
221 transactionTypeIn in varchar2 default null);
222 --
223 -- ----------------------------------------------------------------------------
224 -- |-----------------------------< clearinsertion >-------------------------|
225 -- ----------------------------------------------------------------------------
226 --
227 -- {Start Of Comments}
228 /*#
229 * This API will clear the approver previously inserted using
230 * insertApprover API from the transaction's approver list.Use this API
231 * to remove an inserted approver from a transaction's approver list.
232 *
233 * <p><b>Licensing</b><br>
234 * This API is available for use with any licensed component of the e-business
235 * suite.
236 *
237 * <p><b>Prerequisites</b><br>
238 * The approver must have been previously inserted using insertApprover.
239 *
240 * <p><b>Post Success</b><br>
241 * The insertion of the approver will be cleared.
242 *
243 * <p><b>Post Failure</b><br>
244 * The API will raise an error.
245 *
246 * @param approverIn This is the approverRecord defined by ame_util.approverRecord
247 * which gives information regarding the Approver.
248 * @param applicationidin The fnd_application.application_id value of the
249 * originating application calling the AME API routine.
250 * @param transactionidin This is a string up to 50 bytes long. It identifies a
251 * transaction within a transaction type. Its value must not contain
252 * white-space characters, and must not be the character representation of a
253 * negative integer.
254 * @param transactiontypein This is a string parameter up to 50 bytes long. It
255 * distinguishes one transaction type from another, within a given originating
256 * application. It can be null, but you must always pass its value explicitly.
257 * @rep:displayname Clear Insertion
258 * @rep:category BUSINESS_ENTITY AME_APPROVAL
259 * @rep:lifecycle active
260 * @rep:scope public
261 */
262 --
263 -- {End Of Comments}
264 --
265 procedure clearInsertion(approverIn in ame_util.approverRecord,
266 applicationIdIn in integer,
267 transactionIdIn in varchar2,
268 transactionTypeIn in varchar2 default null);
269 --
270 -- ----------------------------------------------------------------------------
271 -- |-----------------------------< clearinsertions >-------------------------|
272 -- ----------------------------------------------------------------------------
273 --
274 -- {Start Of Comments}
275 /*#
276 * This API removes all the inserted approvers from the specified transaction.
277 * Use this API to remove all the insertions from a transaction at once. This
278 * API also clears the forwardings.
279 *
280 * <p><b>Licensing</b><br>
281 * This API is available for use with any licensed component of the e-business
282 * suite.
283 *
284 * <p><b>Prerequisites</b><br>
285 * No known prerequisites.
286 *
287 * <p><b>Post Success</b><br>
288 * All the inserted approvers will be removed from the specified transaction.
289 *
290 * <p><b>Post Failure</b><br>
291 * The API will raise an error.
292 *
293 * @param applicationidin The fnd_application.application_id value of the
294 * originating application calling the AME API routine.
295 * @param transactionidin This is a string up to 50 bytes long. It identifies a
296 * transaction within a transaction type. Its value must not contain
297 * white-space characters, and must not be the character representation of a
298 * negative integer.
299 * @param transactiontypein This is a string parameter up to 50 bytes long. It
300 * distinguishes one transaction type from another, within a given originating
301 * application. It can be null, but you must always pass its value explicitly.
302 * @rep:displayname Clear Insertions
303 * @rep:category BUSINESS_ENTITY AME_APPROVAL
304 * @rep:lifecycle active
305 * @rep:scope public
306 */
307 --
308 -- {End Of Comments}
309 --
310 procedure clearInsertions(applicationIdIn in integer,
311 transactionIdIn in varchar2,
312 transactionTypeIn in varchar2 default null);
313 --
314 -- ----------------------------------------------------------------------------
315 -- |-----------------------------< deleteapprover >-------------------------|
316 -- ----------------------------------------------------------------------------
317 --
318 -- {Start Of Comments}
319 /*#
320 * This API suppresses the approver
321 * represented by approverIn in the input transaction's approver
322 * list.
323 *
324 * <p><b>Licensing</b><br>
325 * This API is available for use with any licensed component of the e-business
326 * suite.
327 *
328 * <p><b>Prerequisites</b><br>
329 * This procedure should be called only after getNextApprover or
330 * getAllApprovers has been called, for a given transaction.
331 *
332 * <p><b>Post Success</b><br>
333 * The specified approver will be suppressed in the given transaction's approver list.
334 *
335 * <p><b>Post Failure</b><br>
336 * The API will raise an error.
337 *
338 * @param applicationidin The fnd_application.application_id value of the
339 * originating application calling the AME API routine.
340 * @param transactionidin This is a string up to 50 bytes long. It identifies a
341 * transaction within a transaction type. Its value must not contain
342 * white-space characters, and must not be the character representation of a
343 * negative integer.
344 * @param approverIn This is the approverRecord defined by ame_util.approverRecord
345 * which gives information regarding the Approver.
346 * @param transactiontypein This is a string parameter up to 50 bytes long. It
347 * distinguishes one transaction type from another, within a given originating
348 * application. It can be null, but you must always pass its value explicitly.
349 * @rep:displayname Delete Approver
350 * @rep:category BUSINESS_ENTITY AME_APPROVAL
351 * @rep:lifecycle active
352 * @rep:scope public
353 */
354 --
355 -- {End Of Comments}
356 --
357 procedure deleteApprover(applicationIdIn in integer,
358 transactionIdIn in varchar2,
359 approverIn in ame_util.approverRecord,
360 transactionTypeIn in varchar2 default null);
364 -- ----------------------------------------------------------------------------
361 --
362 -- ----------------------------------------------------------------------------
363 -- |-----------------------------< deleteapprovers >-------------------------|
365 --
366 -- {Start Of Comments}
367 /*#
368 * This API suppresses the approvers
369 * represented by approversIn in the input transaction's approver
370 * list.
371 *
372 * <p><b>Licensing</b><br>
373 * This API is available for use with any licensed component of the e-business
374 * suite.
375 *
376 * <p><b>Prerequisites</b><br>
377 * This procedure should be called only after getNextApprover or
378 * getAllApprovers has been called, for a given transaction.
379 *
380 * <p><b>Post Success</b><br>
381 * The specified approvers will be suppressed in the given transaction's approval list.
382 *
383 * <p><b>Post Failure</b><br>
384 * The API will raise an error.
385 *
386 * @param applicationidin The fnd_application.application_id value of the
387 * originating application calling the AME API routine.
388 * @param transactionidin This is a string up to 50 bytes long. It identifies a
389 * transaction within a transaction type. Its value must not contain
390 * white-space characters, and must not be the character representation of a
391 * negative integer.
392 * @param approversIn This is the approversTable defined by ame_util.approversTable
393 * which gives information regarding the Approvers.
394 * @param transactiontypein This is a string parameter up to 50 bytes long. It
395 * distinguishes one transaction type from another, within a given originating
396 * application. It can be null, but you must always pass its value explicitly.
397 * @rep:displayname Delete Approvers
398 * @rep:category BUSINESS_ENTITY AME_APPROVAL
399 * @rep:lifecycle active
400 * @rep:scope public
401 */
402 --
403 -- {End Of Comments}
404 --
405 procedure deleteApprovers(applicationIdIn in integer,
406 transactionIdIn in varchar2,
407 approversIn in ame_util.approversTable,
408 transactionTypeIn in varchar2 default null);
409 --
410 -- ----------------------------------------------------------------------------
411 -- |-----------------------------< getadminapprover >-------------------------|
412 -- ----------------------------------------------------------------------------
413 --
414 -- {Start Of Comments}
415 /*#
416 * This API returns the administrator for the input transaction type.
417 *
418 * This adminstrator user's information can be specified in AME using the admin
419 * tab. This API can be used to get the admin approver in case of any errors
420 * and so on. Note : This is an alternative API for ame_api3.getAdminApprover.
421 *
422 * <p><b>Licensing</b><br>
423 * This API is available for use with any licensed component of the e-business
424 * suite.
425 *
426 * <p><b>Prerequisites</b><br>
427 * No known prerequisites.
428 *
429 * <p><b>Post Success</b><br>
430 * This API will return the administrator user's information in the out
431 * parameter adminApproverOut.
435 *
432 *
433 * <p><b>Post Failure</b><br>
434 * The API will raise an error.
436 * @param applicationidin The fnd_application.application_id value of the
437 * originating application calling the AME API routine.
438 * @param transactiontypein This is a string parameter up to 50 bytes long. It
439 * distinguishes one transaction type from another, within a given originating
440 * application. It can be null, but you must always pass its value explicitly.
441 * @param adminapproverout Admin approver in ame_util.approverrecord format.
442 * @rep:displayname Get Admin Approver
443 * @rep:category BUSINESS_ENTITY AME_APPROVAL
444 * @rep:lifecycle active
445 * @rep:scope public
446 */
447 --
448 -- {End Of Comments}
449 --
450 procedure getAdminApprover(applicationIdIn in integer default null,
451 transactionTypeIn in varchar2 default null,
452 adminApproverOut out nocopy ame_util.approverRecord);
453 --
454 -- ----------------------------------------------------------------------------
455 -- |-----------------------------< getallapprovers >--------------------------|
456 -- ----------------------------------------------------------------------------
457 --
458 -- {Start Of Comments}
459 /*#
460 * This API returns all the approvers for a transaction.
461 *
462 * This API outputs the input transaction's current approver list, including
463 * rule-generated, inserted, suppressed, and repeated approvers. The rows in
464 * approversOut are indexed by consecutive ascending integers starting at one.
465 * The approval_status values in approversOut reflect each approver's most
466 * recent response to any request for approval they have received, assuming the
467 * originating application has passed such responses to AME via
468 * updateApprovalStatus or updateApprovalStatus2. In AME 11.5.9, the AME engine
469 * excluded from the approver list any approvers deleted by calls to
470 * ame_api.deleteApprover(s), or suppressed to account for the value of the
471 * repeatedApprovers configuration variable. In AME 11.5.10, this behavior has
472 * changed. The approver list in approversOut now includes deleted and repeated
473 * approvers, but assigns them one of the approval_status values
474 * ame_util.suppressedStatus and ame_util.repeatedStatus. Your code should
475 * treat these statuses as logically equivalent to ame_util.approvedStatus. The
476 * ame_api.getNextApprover will skip approvers with either status when it
477 * iterates through the approver list to find the first approver that has not
478 * yet approved. Note : This is an alternative API for
479 * ame_api2.getAllApprovers7 See also the ame_api2.getAllApprovers[n]
480 * procedures.
481 *
482 * <p><b>Licensing</b><br>
483 * This API is available for use with any licensed component of the e-business
484 * suite.
485 *
486 * <p><b>Prerequisites</b><br>
487 * No known prerequisites.
488 *
489 * <p><b>Post Success</b><br>
490 * The API will return all the approvers in the out parameter approversOut.
491 *
492 * <p><b>Post Failure</b><br>
493 * The API will not return any approver for the particular transaction and will
494 * raise an error.
495 *
496 * @param applicationidin The fnd_application.application_id value of the
497 * originating application calling the AME API routine.
498 * @param transactionidin This is a string up to 50 bytes long. It identifies a
499 * transaction within a transaction type. Its value must not contain
500 * white-space characters, and must not be the character representation of a
501 * negative integer.
502 * @param transactiontypein This is a string parameter up to 50 bytes long. It
503 * distinguishes one transaction type from another, within a given originating
504 * application. It can be null, but you must always pass its value explicitly.
505 * @param approversout This is the ame_util.approversTable which represents the
506 * list of approvers.
507 * @rep:displayname Get All Approvers
508 * @rep:category BUSINESS_ENTITY AME_APPROVAL
509 * @rep:lifecycle active
510 * @rep:scope public
511 */
512 --
513 -- {End Of Comments}
514 --
515 procedure getAllApprovers(applicationIdIn in integer,
516 transactionIdIn in varchar2,
517 transactionTypeIn in varchar2 default null,
518 approversOut out nocopy ame_util.approversTable);
519 --
520 -- ----------------------------------------------------------------------------
521 -- |-----------------------------< getandrecordallapprovers >------------------|
522 -- ----------------------------------------------------------------------------
523 --
524 -- {Start Of Comments}
525 /*#
526 * This API returns all the approvers for a transaction.
527 * This API is similar to ame_api.getAllApprovers. The only
528 * difference is that this call will also store the approver list in the
529 * AME transaction tables.
530 *
531 * <p><b>Licensing</b><br>
532 * This API is available for use with any licensed component of the e-business
533 * suite.
534 *
535 * <p><b>Prerequisites</b><br>
536 * No known prerequisites.
537 *
538 * <p><b>Post Success</b><br>
539 * The API will return all the approvers in the out parameter approversOut.
540 *
541 * <p><b>Post Failure</b><br>
542 * The API will not return any approver for the particular transaction and will
543 * raise an error.
544 *
548 * transaction within a transaction type. Its value must not contain
545 * @param applicationidin The fnd_application.application_id value of the
546 * originating application calling the AME API routine.
547 * @param transactionidin This is a string up to 50 bytes long. It identifies a
549 * white-space characters, and must not be the character representation of a
550 * negative integer.
551 * @param transactiontypein This is a string parameter up to 50 bytes long. It
552 * distinguishes one transaction type from another, within a given originating
553 * application. It can be null, but you must always pass its value explicitly.
554 * @param approversout This is the ame_util.approversTable which represents the
555 * list of approvers.
556 * @rep:displayname Get And Record All Approvers
557 * @rep:category BUSINESS_ENTITY AME_APPROVAL
558 * @rep:lifecycle active
559 * @rep:scope public
560 */
561 --
562 -- {End Of Comments}
563 --
564 procedure getAndRecordAllApprovers(applicationIdIn in integer,
565 transactionIdIn in varchar2,
566 transactionTypeIn in varchar2 default null,
567 approversOut out nocopy ame_util.approversTable);
568 --
569 -- ----------------------------------------------------------------------------
570 -- |---------------------------< getapplicablerules1 >------------------------|
571 -- ----------------------------------------------------------------------------
572 --
573 -- {Start Of Comments}
574 /*#
575 * This API returns the rules that apply to primary key information for a
576 * transaction.
577 *
578 * Use this API when you only need the rule IDs. Note : This is an alternative
579 * API for ame_api3.getapplicablerules1. See also ame_api.getApplicableRules2
580 * and getApplicableRules3.
581 *
582 * <p><b>Licensing</b><br>
583 * This API is available for use with any licensed component of the e-business
584 * suite.
585 *
586 * <p><b>Prerequisites</b><br>
587 * No known prerequisites.
588 *
589 * <p><b>Post Success</b><br>
590 * The API will return the ids of the applicable rules in the out parameter
591 * ruleIdsOut.
592 *
593 * <p><b>Post Failure</b><br>
594 * The API will raise an error.
595 *
596 * @param applicationidin The fnd_application.application_id value of the
597 * originating application calling the AME API routine.
598 * @param transactionidin This is a string up to 50 bytes long. It identifies a
599 * transaction within a transaction type. Its value must not contain
600 * white-space characters, and must not be the character representation of a
601 * negative integer.
602 * @param transactiontypein This is a string parameter up to 50 bytes long. It
603 * distinguishes one transaction type from another, within a given originating
604 * application. It can be null, but you must always pass its value explicitly.
605 * @param ruleidsout Applicable rules for the input transaction.
606 * @rep:displayname Get Applicable Rules1
607 * @rep:category BUSINESS_ENTITY AME_APPROVAL
608 * @rep:lifecycle active
609 * @rep:scope public
610 */
611 --
612 -- {End Of Comments}
613 --
614 procedure getApplicableRules1(applicationIdIn in integer,
615 transactionIdIn in varchar2,
616 transactionTypeIn in varchar2 default null,
617 ruleIdsOut out nocopy ame_util.idList);
618 --
619 -- ----------------------------------------------------------------------------
620 -- |---------------------------< getapplicablerules2 >------------------------|
621 -- ----------------------------------------------------------------------------
622 --
623 -- {Start Of Comments}
624 /*#
625 * This API returns the description of the rules that are applicable for a
626 * transaction.
627 *
628 * Use this API when you only need the rule descriptions. Note : This is an
629 * alternative API for ame_api3.getApplicableRules2. See also
630 * ame_api.getApplicableRules1 and ame_api.getApplicableRules3.
631 *
632 * <p><b>Licensing</b><br>
633 * This API is available for use with any licensed component of the e-business
634 * suite.
635 *
636 * <p><b>Prerequisites</b><br>
637 * No known prerequisites.
638 *
639 * <p><b>Post Success</b><br>
640 * The API will return the descriptions of all the applicable rules for a
641 * transaction in the out parameter ruleDescriptionsOut.
642 *
643 * <p><b>Post Failure</b><br>
644 * The API will raise an error.
645 *
646 * @param applicationidin The fnd_application.application_id value of the
647 * originating application calling the AME API routine.
648 * @param transactionidin This is a string up to 50 bytes long. It identifies a
649 * transaction within a transaction type. Its value must not contain
650 * white-space characters, and must not be the character representation of a
651 * negative integer.
652 * @param transactiontypein This is a string parameter up to 50 bytes long. It
653 * distinguishes one transaction type from another, within a given originating
654 * application. It can be null, but you must always pass its value explicitly.
655 * @param ruledescriptionsout Rule descriptions for the rules that are
656 * applicable for the input transaction.
657 * @rep:displayname Get Applicable Rules2
658 * @rep:category BUSINESS_ENTITY AME_APPROVAL
659 * @rep:lifecycle active
660 * @rep:scope public
661 */
665 procedure getApplicableRules2(applicationIdIn in integer,
662 --
663 -- {End Of Comments}
664 --
666 transactionIdIn in varchar2,
667 transactionTypeIn in varchar2 default null,
668 ruleDescriptionsOut out nocopy ame_util.stringList);
669 --
670 -- ----------------------------------------------------------------------------
671 -- |---------------------------< getapplicablerules3 >------------------------|
672 -- ----------------------------------------------------------------------------
673 --
674 -- {Start Of Comments}
675 /*#
676 * This API returns the rules that apply to primary keys, and returns their
677 * corresponding descriptions for a transaction.
678 *
679 * This procedure is useful to construct a displayable list of descriptions of
680 * applicable rules, where each rule description hyperlinks to a more detailed
681 * description of the rule (generated by one of the ame_api.getRuleDetails[n]
682 * procedures). Note : This is an alternative API for
683 * ame_api3.getApplicableRules3 See also ame_api.getApplicableRules1,
684 * ame_api.getApplicableRules1, and the three ame_api.getRuleDetails[n]
685 * procedures.
686 *
687 * <p><b>Licensing</b><br>
688 * This API is available for use with any licensed component of the e-business
689 * suite.
690 *
691 * <p><b>Prerequisites</b><br>
692 * No known prerequisites.
693 *
694 * <p><b>Post Success</b><br>
695 * The API will return the applicable rules' ids and descriptions for a
696 * transaction in the out parameters ruleIdsOut and ruleDescriptionsOut.
697 *
698 * <p><b>Post Failure</b><br>
699 * The API will raise an error.
700 *
701 * @param applicationidin The fnd_application.application_id value of the
702 * originating application calling the AME API routine.
703 * @param transactionidin This is a string up to 50 bytes long. It identifies a
704 * transaction within a transaction type. Its value must not contain
705 * white-space characters, and must not be the character representation of a
706 * negative integer.
707 * @param transactiontypein This is a string parameter up to 50 bytes long. It
708 * distinguishes one transaction type from another, within a given originating
709 * application. It can be null, but you must always pass its value explicitly.
710 * @param ruleidsout Rule ids for the rules that are applicable for the input
711 * transaction.
712 * @param ruledescriptionsout Rule descriptions for the rules that are
713 * applicable for the input transaction.
714 * @rep:displayname Get Applicable Rules3
715 * @rep:category BUSINESS_ENTITY AME_APPROVAL
716 * @rep:lifecycle active
717 * @rep:scope public
718 */
719 --
720 -- {End Of Comments}
721 --
722 procedure getApplicableRules3(applicationIdIn in integer,
723 transactionIdIn in varchar2,
724 transactionTypeIn in varchar2 default null,
725 ruleIdsOut out nocopy ame_util.idList,
726 ruleDescriptionsOut out nocopy ame_util.stringList);
727 --
728 -- ----------------------------------------------------------------------------
729 -- |--------------------------< getapproversandrules1 >-----------------------|
730 -- ----------------------------------------------------------------------------
731 --
732 -- {Start Of Comments}
733 /*#
734 * This API returns the list of approvers (both rule-generated and inserted
735 * approvers) along with rule primary keys requiring each approver for a
736 * transaction.
737 *
738 * Use this API when you need to display the approver list, along with the
739 * rules requiring each approver. Note : This is an alternative API for
740 * ame_api2.getAllApprovers4.
741 *
742 * <p><b>Licensing</b><br>
743 * This API is available for use with any licensed component of the e-business
744 * suite.
745 *
746 * <p><b>Prerequisites</b><br>
747 * No known prerequisites.
748 *
749 * <p><b>Post Success</b><br>
750 * This API will return the list of approvers along with rule ids requiring
751 * each approvers in the out parameters approversOut and ruleIdsOut.
752 *
753 * <p><b>Post Failure</b><br>
754 * The API will raise an error.
755 *
756 * @param applicationidin The fnd_application.application_id value of the
757 * originating application calling the AME API routine.
758 * @param transactionidin This is a string up to 50 bytes long. It identifies a
759 * transaction within a transaction type. Its value must not contain
760 * white-space characters, and must not be the character representation of a
761 * negative integer.
762 * @param transactiontypein This is a string parameter up to 50 bytes long. It
763 * distinguishes one transaction type from another, within a given originating
764 * application. It can be null, but you must always pass its value explicitly.
765 * @param approversout This is the ame_util.approversTable which represents the
766 * list of approvers.
767 * @param ruleidsout Rule ids for the rules corresponding to each of the
768 * approvers.
769 * @rep:displayname Get Approvers And Rules1
770 * @rep:category BUSINESS_ENTITY AME_APPROVAL
771 * @rep:lifecycle active
772 * @rep:scope public
773 */
774 --
775 -- {End Of Comments}
776 --
777 procedure getApproversAndRules1(applicationIdIn in integer,
781 ruleIdsOut out nocopy ame_util.idList);
778 transactionIdIn in varchar2,
779 transactionTypeIn in varchar2 default null,
780 approversOut out nocopy ame_util.approversTable,
782 --
783 -- ----------------------------------------------------------------------------
784 -- |--------------------------< getapproversandrules2 >-----------------------|
785 -- ----------------------------------------------------------------------------
786 --
787 -- {Start Of Comments}
788 /*#
789 * This API returns the list of approvers (both rule-generated and inserted
790 * approvers) along with rule descriptions requiring each approver for a
791 * transaction.
792 *
793 * The getapproversandrules2 procedure has the same functionality as
794 * ame_api.getapproversandrules1, but it returns rule descriptions rather than
795 * rule IDs. Note : This is an alternative API for ame_api2.getAllApprovers5.
796 * See also ame_api.getapproversandrules1.
797 *
798 * <p><b>Licensing</b><br>
799 * This API is available for use with any licensed component of the e-business
800 * suite.
801 *
802 * <p><b>Prerequisites</b><br>
803 * No known prerequisites.
804 *
805 * <p><b>Post Success</b><br>
806 * This API will return the list of approvers (both rule-generated and inserted
807 * approvers) along with rule descriptions requiring each approvers for a
808 * transaction in the out parameters approversOut and ruleDescriptionsOut.
809 *
810 * <p><b>Post Failure</b><br>
811 * The API will raise an error.
812 *
813 * @param applicationidin The fnd_application.application_id value of the
814 * originating application calling the AME API routine.
815 * @param transactionidin This is a string up to 50 bytes long. It identifies a
816 * transaction within a transaction type. Its value must not contain
817 * white-space characters, and must not be the character representation of a
818 * negative integer.
819 * @param transactiontypein This is a string parameter up to 50 bytes long. It
820 * distinguishes one transaction type from another, within a given originating
821 * application. It can be null, but you must always pass its value explicitly.
822 * @param approversout This is the ame_util.approversTable which represents the
823 * list of approvers.
824 * @param ruledescriptionsout Rule descriptions for the rules corresponding to
825 * each of the approvers.
826 * @rep:displayname Get Approvers And Rules2
827 * @rep:category BUSINESS_ENTITY AME_APPROVAL
828 * @rep:lifecycle active
829 * @rep:scope public
830 */
831 --
832 -- {End Of Comments}
833 --
834 procedure getApproversAndRules2(applicationIdIn in integer,
835 transactionIdIn in varchar2,
836 transactionTypeIn in varchar2 default null,
837 approversOut out nocopy ame_util.approversTable,
838 ruleDescriptionsOut out nocopy ame_util.stringList);
839 --
840 -- ----------------------------------------------------------------------------
841 -- |--------------------------< getapproversandrules3 >-----------------------|
842 -- ----------------------------------------------------------------------------
843 --
844 -- {Start Of Comments}
845 /*#
846 * This API returns the list of approvers (both rule-generated and inserted
847 * approvers) along with rules (both description and primary key) requiring
848 * each approver.
849 *
850 * The ame_api.getapproversandrules3 procedure has the same functionality as
851 * getapproversandrules2, but it returns both rule IDs and rule descriptions.
852 * Note : This API is an alternative API for ame_api2.getAllApprovers6. See
853 * also ame_api.getapproversandrules1 and ame_api.getapproversandrules2.
854 *
855 * <p><b>Licensing</b><br>
856 * This API is available for use with any licensed component of the e-business
857 * suite.
858 *
859 * <p><b>Prerequisites</b><br>
860 * No known prerequisites.
861 *
862 * <p><b>Post Success</b><br>
863 * This API will return the list of approvers (both rule-generated and inserted
864 * approvers) along with rule ids and descriptions requiring each approvers in
865 * the out parameters approversOut, ruleIdsOut and ruleDescriptionsOut.
866 *
867 * <p><b>Post Failure</b><br>
868 * The API will raise an error.
869 *
870 * @param applicationidin The fnd_application.application_id value of the
871 * originating application calling the AME API routine.
872 * @param transactionidin This is a string up to 50 bytes long. It identifies a
873 * transaction within a transaction type. Its value must not contain
874 * white-space characters, and must not be the character representation of a
875 * negative integer.
876 * @param transactiontypein This is a string parameter up to 50 bytes long. It
877 * distinguishes one transaction type from another, within a given originating
878 * application. It can be null, but you must always pass its value explicitly.
879 * @param approversout This is the ame_util.approversTable which represents the
880 * list of approvers.
881 * @param ruleidsout Rule ids for the rules corresponding to each of the
882 * approvers.
883 * @param ruledescriptionsout Rule descriptions for the rules corresponding to
884 * each of the approvers.
885 * @rep:displayname Get Approvers And Rules3
886 * @rep:category BUSINESS_ENTITY AME_APPROVAL
890 --
887 * @rep:lifecycle active
888 * @rep:scope public
889 */
891 -- {End Of Comments}
892 --
893 procedure getApproversAndRules3(applicationIdIn in integer,
894 transactionIdIn in varchar2,
895 transactionTypeIn in varchar2 default null,
896 approversOut out nocopy ame_util.approversTable,
897 ruleIdsOut out nocopy ame_util.idList,
898 ruleDescriptionsOut out nocopy ame_util.stringList);
899 --
900 -- ----------------------------------------------------------------------------
901 -- |--------------------------< getAvailableInsertions >-----------------------|
902 -- ----------------------------------------------------------------------------
903 --
904 -- {Start Of Comments}
905 /*#
906 * This API returns a list of ame_util.insertionRecord records representing
907 * the dynamic approver insertions that are possible at the absolute
908 * position positionIn in the transaction's current approver list.
909 *
910 * <p><b>Licensing</b><br>
911 * This API is available for use with any licensed component of the e-business
912 * suite.
913 *
914 * <p><b>Prerequisites</b><br>
915 * No known prerequisites.
916 *
917 * <p><b>Post Success</b><br>
918 * The API will return a list of available insertions in the out parameter
919 * availableInsertionsOut.
920 *
921 * <p><b>Post Failure</b><br>
922 * The API will raise an error.
923 *
924 * @param applicationidin The fnd_application.application_id value of the
925 * originating application calling the AME API routine.
926 * @param transactionidin This is a string up to 50 bytes long. It identifies a
927 * transaction within a transaction type. Its value must not contain
928 * white-space characters, and must not be the character representation of a
929 * negative integer.
930 * @param positionIn This specifies the index in the Approval Order where the
931 * available insertions are to be fetched.
932 * @param transactiontypein This is a string parameter up to 50 bytes long. It
933 * distinguishes one transaction type from another, within a given originating
934 * application. It can be null, but you must always pass its value explicitly.
935 * @param availableInsertionsOut This is the table defined by ame_util.insertionsTable
936 * which represents the list of available insertions.
937 * @rep:displayname Get Available Insertions
938 * @rep:category BUSINESS_ENTITY AME_APPROVAL
939 * @rep:lifecycle active
940 * @rep:scope public
941 */
942 --
943 -- {End Of Comments}
944 --
945 procedure getAvailableInsertions(applicationIdIn in integer,
946 transactionIdIn in varchar2,
947 positionIn in integer,
948 transactionTypeIn in varchar2 default null,
949 availableInsertionsOut out nocopy ame_util.insertionsTable);
950 --
951 -- ----------------------------------------------------------------------------
952 -- |--------------------------< getAvailableOrders >-----------------------|
953 -- ----------------------------------------------------------------------------
954 --
955 -- {Start Of Comments}
956 /*#
957 * Returns a list of ame_util.orderRecord records representing
958 * the dynamic approver insertions that are possible at the absolute
959 * position positionIn in the transaction's current approver list.
960 *
961 * <p><b>Licensing</b><br>
962 * This API is available for use with any licensed component of the e-business
963 * suite.
964 *
965 * <p><b>Prerequisites</b><br>
966 * No known prerequisites.
967 *
968 * <p><b>Post Success</b><br>
969 * The API will return the list of available orders in the out parameter
970 * availableOrdersOut.
971 *
972 * <p><b>Post Failure</b><br>
973 * The API will raise an error.
974 *
975 * @param applicationidin The fnd_application.application_id value of the
976 * originating application calling the AME API routine.
977 * @param transactionidin This is a string up to 50 bytes long. It identifies a
978 * transaction within a transaction type. Its value must not contain
979 * white-space characters, and must not be the character representation of a
980 * negative integer.
981 * @param positionIn absolute position in the current approver list.
982 * @param transactiontypein This is a string parameter up to 50 bytes long. It
983 * distinguishes one transaction type from another, within a given originating
984 * application. It can be null, but you must always pass its value explicitly.
985 * @param availableOrdersOut This is the table defined by ame_util.ordersTable
986 * which represents the list of available orders.
987 * @rep:displayname Get Available Orders
988 * @rep:category BUSINESS_ENTITY AME_APPROVAL
989 * @rep:lifecycle active
990 * @rep:scope public
991 */
992 --
993 -- {End Of Comments}
994 --
995 procedure getAvailableOrders(applicationIdIn in integer,
996 transactionIdIn in varchar2,
997 positionIn in integer,
998 transactionTypeIn in varchar2 default null,
999 availableOrdersOut out nocopy ame_util.ordersTable);
1000 --
1001 -- ----------------------------------------------------------------------------
1005 -- {Start Of Comments}
1002 -- |---------------------------< getconditiondetails >------------------------|
1003 -- ----------------------------------------------------------------------------
1004 --
1006 /*#
1007 * This API returns the details of an AME condition.
1008 *
1009 * This API is an alternative for ame_api3.getconditiondetails.
1010 *
1011 * <p><b>Licensing</b><br>
1012 * This API is available for use with any licensed component of the e-business
1013 * suite.
1014 *
1015 * <p><b>Prerequisites</b><br>
1016 * No known prerequisites.
1017 *
1018 * <p><b>Post Success</b><br>
1019 * The API will return the condition details along with the attribute on which
1020 * the condition is based, in out parameters attributeNameOut,
1021 * attributeTypeOut, attributeDescriptionOut, lowerLimitOut upperLimitOut,
1022 * includeLowerLimitOut, includeUpperLimitOut, currencyCodeOut and
1023 * allowedValuesOut.
1024 *
1025 * <p><b>Post Failure</b><br>
1026 * The API will raise an error.
1027 *
1028 * @param conditionidin Condition id
1029 * @param attributenameout Attribute name, on which condition is based.
1030 * @param attributetypeout Attribute type, for example, number, currency,
1031 * string.
1032 * @param attributedescriptionout Attribute description.
1033 * @param lowerlimitout Lower Limit. For number and currency type it contains
1034 * the lower value. For boolean type it contains true or false,and for string
1035 * type, it contains null.
1036 * @param upperlimitout Upper Limit. For number and currency type it contains
1037 * the upper value. For boolean and string type it contains contains null.
1038 * @param includelowerlimitout For number and currency type it determines
1039 * whether the Lower Limit is included, otherwise it contains null.
1040 * @param includeupperlimitout For number and currency type it determines
1041 * whether the Upper Limit is included, otherwise it contains null.
1042 * @param currencycodeout For currency type, it contains the General Ledger
1043 * currency code, otherwise null.
1044 * @param allowedvaluesout For string type conditions it contains the list of
1045 * values, otherwise null.
1046 * @rep:displayname Get Condition Details
1047 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1048 * @rep:lifecycle active
1049 * @rep:scope public
1050 */
1051 --
1052 -- {End Of Comments}
1053 --
1054 procedure getConditionDetails(conditionIdIn in integer,
1055 attributeNameOut out nocopy varchar2,
1056 attributeTypeOut out nocopy varchar2,
1057 attributeDescriptionOut out nocopy varchar2,
1058 lowerLimitOut out nocopy varchar2,
1059 upperLimitOut out nocopy varchar2,
1060 includeLowerLimitOut out nocopy varchar2,
1061 includeUpperLimitOut out nocopy varchar2,
1062 /*
1063 includeLowerLimitOut and includeUpperLimitOut will be
1064 ame_util.booleanTrue, ame_util.booleanFalse, or null.
1065 */
1066 currencyCodeOut out nocopy varchar2,
1067 allowedValuesOut out nocopy ame_util.longestStringList);
1068 --
1069 -- ----------------------------------------------------------------------------
1070 -- |-----------------------------< getGroupMembers >--------------------------|
1071 -- ----------------------------------------------------------------------------
1072 --
1073 -- {Start Of Comments}
1074 /*#
1075 * This API returns constituent member of a AME approver group.
1076 *
1077 * <p><b>Licensing</b><br>
1078 * This API is available for use with any licensed component of the e-business
1079 * suite.
1080 *
1081 * <p><b>Prerequisites</b><br>
1082 * No known prerequisites.
1083 *
1084 * <p><b>Post Success</b><br>
1085 * The API will return the details of constituent members of the specified approver
1086 * group in the out parameters memberOrderNumbersOut,memberPersonIdsOut,memberUserIdsOut.
1087 *
1088 * <p><b>Post Failure</b><br>
1089 * The API will raise an error.
1090 *
1091 * @param applicationidin The fnd_application.application_id value of the
1092 * originating application calling the AME API routine.
1093 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1094 * transaction within a transaction type. Its value must not contain
1095 * white-space characters, and must not be the character representation of a
1096 * negative integer.
1097 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1098 * distinguishes one transaction type from another, within a given originating
1099 * application. It can be null, but you must always pass its value explicitly.
1100 * @param groupIdIn Group id of the AME approval group.
1101 * @param memberOrderNumbersOut list of order numbers of the members.
1102 * @param memberPersonIdsOut list of person_id of the members.
1103 * @param memberUserIdsOut list of user_id of the members.
1104 * @rep:displayname Get Group Members
1105 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1106 * @rep:lifecycle active
1107 * @rep:scope public
1108 */
1109 --
1110 -- {End Of Comments}
1111 --
1112 procedure getGroupMembers(applicationIdIn in number,
1113 transactionTypeIn in varchar2,
1114 transactionIdIn in varchar2,
1118 memberUserIdsOut out nocopy ame_util.idList);
1115 groupIdIn in number,
1116 memberOrderNumbersOut out nocopy ame_util.idList,
1117 memberPersonIdsOut out nocopy ame_util.idList,
1119 --
1120 -- ----------------------------------------------------------------------------
1121 -- |-----------------------------< getnextapprover >--------------------------|
1122 -- ----------------------------------------------------------------------------
1123 --
1124 -- {Start Of Comments}
1125 /*#
1126 * This API returns the next approver in the approver list from whom an
1127 * approval response is required.
1128 *
1129 * The returned approver should respond (approve/reject/forward etc) the input
1130 * transaction. Unlike the ame_api2.getNextApprovers[n] procedures,
1131 * ame_api.getNextApprover returns the same approver each time the procedure is
1132 * called for a transaction, until the approver responds the input transaction.
1133 * Note : This API is an alternative API for ame_api2.getNextApprovers4.
1134 *
1135 * <p><b>Licensing</b><br>
1136 * This API is available for use with any licensed component of the e-business
1137 * suite.
1138 *
1139 * <p><b>Prerequisites</b><br>
1140 * No known prerequisites.
1141 *
1142 * <p><b>Post Success</b><br>
1143 * The API will return the next approver in the out parameter
1144 * nextApproverOut.
1145 *
1146 * <p><b>Post Failure</b><br>
1147 * This API will not return any approver and will raise an error.
1148 *
1149 * @param applicationidin The fnd_application.application_id value of the
1150 * originating application calling the AME API routine.
1151 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1152 * transaction within a transaction type. Its value must not contain
1153 * white-space characters, and must not be the character representation of a
1154 * negative integer.
1155 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1156 * distinguishes one transaction type from another, within a given originating
1157 * application. It can be null, but you must always pass its value explicitly.
1158 * @param nextapproverout This is an ame_util.approverRecord which identifies
1159 * the approver, requiring notification for
1160 * the current stage of the input transaction's approval process.
1161 * @rep:displayname Get Next Approver
1162 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1163 * @rep:lifecycle active
1164 * @rep:scope public
1165 */
1166 --
1167 -- {End Of Comments}
1168 --
1169 procedure getNextApprover(applicationIdIn in integer,
1170 transactionIdIn in varchar2,
1171 transactionTypeIn in varchar2 default null,
1172 nextApproverOut out nocopy ame_util.approverRecord);
1173 --
1174 -- ----------------------------------------------------------------------------
1175 -- |-----------------------------< getoldapprovers >--------------------------|
1176 -- ----------------------------------------------------------------------------
1177 --
1178 -- {Start Of Comments}
1179 /*#
1180 * This API returns the approver list that AME calculated when it last
1181 * generated an approver list for the input transaction.
1182 *
1183 * This is an alternative API for ame_api3.getOldApprovers. Note : Do not use
1184 * this api for your approval process. This API is a deprecated routine
1185 * available only for the sake of backwards compatibility.
1186 *
1187 * <p><b>Licensing</b><br>
1188 * This API is available for use with any licensed component of the e-business
1189 * suite.
1190 *
1191 * <p><b>Prerequisites</b><br>
1192 * No known prerequisites.
1193 *
1194 * <p><b>Post Success</b><br>
1195 * The API will return the list of approvers in the out parameter
1196 * oldApproversOut
1197 *
1198 * <p><b>Post Failure</b><br>
1199 * The API will not return any approver and will raise an error.
1200 *
1201 * @param applicationidin The fnd_application.application_id value of the
1202 * originating application calling the AME API routine.
1203 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1204 * transaction within a transaction type. Its value must not contain
1205 * white-space characters, and must not be the character representation of a
1206 * negative integer.
1207 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1208 * distinguishes one transaction type from another, within a given originating
1209 * application. It can be null, but you must always pass its value explicitly.
1210 * @param oldapproversout This is an ame_util.approverTable that will keep the
1211 * generated old approvers list.
1212 * @rep:displayname Get Old Approvers
1213 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1214 * @rep:lifecycle active
1215 * @rep:scope public
1216 */
1217 --
1218 -- {End Of Comments}
1219 --
1220 procedure getOldApprovers(applicationIdIn in integer,
1221 transactionIdIn in varchar2,
1222 transactionTypeIn in varchar2 default null,
1223 oldApproversOut out nocopy ame_util.approversTable);
1224 --
1225 -- ----------------------------------------------------------------------------
1226 -- |-----------------------------< getruledetails1 >--------------------------|
1227 -- ----------------------------------------------------------------------------
1228 --
1232 * conditions that apply.
1229 -- {Start Of Comments}
1230 /*#
1231 * This API gets the various rule details including the primary key for the
1233 *
1234 * The following details of a rule are returned. rule type, rule description,
1235 * condition Ids for the conditions used in this rule, action type names and
1236 * descriptions, action descriptions corresponding to actions that are used in
1237 * this rule. Use getRuleDetails1 in connection with one of the
1238 * getApplicableRules procedures. See also the getApplicableRules[n]
1239 * procedures. Note : This API is an alternative API for
1240 * ame_api3.getRuleDetails1
1241 *
1242 * <p><b>Licensing</b><br>
1243 * This API is available for use with any licensed component of the e-business
1244 * suite.
1245 *
1246 * <p><b>Prerequisites</b><br>
1247 * No known prerequisites.
1248 *
1249 * <p><b>Post Success</b><br>
1250 * The API will return the rule details in the various out parameters.
1251 *
1252 * <p><b>Post Failure</b><br>
1253 * The API will raise an error.
1254 *
1255 * @param ruleidin Rule id
1256 * @param ruletypeout Rule type, for example, list creation, list creation and
1257 * exception, list modification and so on.
1258 * @param ruledescriptionout Rule description.
1259 * @param conditionidsout These are condition ids for the conditions that are
1260 * used in the input rule.
1261 * @param approvaltypenameout These are action type names corresponding to the
1262 * actions that are used in the input rule.
1263 * @param approvaltypedescriptionout These are action type descriptions
1264 * corresponding to the actions that are used in the input rule.
1265 * @param approvaldescriptionout These are action descriptions corresponding to
1266 * the actions that are used in the input rule.
1267 * @rep:displayname Get Rule Details 1
1268 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1269 * @rep:lifecycle active
1270 * @rep:scope public
1271 */
1272 --
1273 -- {End Of Comments}
1274 --
1275 procedure getRuleDetails1(ruleIdIn in integer,
1276 ruleTypeOut out nocopy varchar2,
1277 ruleDescriptionOut out nocopy varchar2,
1278 conditionIdsOut out nocopy ame_util.idList,
1279 approvalTypeNameOut out nocopy varchar2,
1280 approvalTypeDescriptionOut out nocopy varchar2,
1281 approvalDescriptionOut out nocopy varchar2);
1282 --
1283 -- ----------------------------------------------------------------------------
1284 -- |-----------------------------< getruledetails2 >--------------------------|
1285 -- ----------------------------------------------------------------------------
1286 --
1287 -- {Start Of Comments}
1288 /*#
1289 * This API gets the rule details including a description of the conditions
1290 * that apply.
1291 *
1292 * This API has the same functionality as getRuleDetails1, but it returns
1293 * condition descriptions rather than condition IDs. Note : This API is an
1294 * alternative for ame_api3.getRuleDetails2. See also ame_api.getRuleDetails1.
1295 *
1296 * <p><b>Licensing</b><br>
1297 * This API is available for use with any licensed component of the e-business
1298 * suite.
1299 *
1300 * <p><b>Prerequisites</b><br>
1301 * No known prerequisites.
1302 *
1303 * <p><b>Post Success</b><br>
1304 * The API will return the rule details in the various out parameters.
1305 *
1306 * <p><b>Post Failure</b><br>
1307 * The API will raise an error.
1308 *
1309 * @param ruleidin Rule id.
1310 * @param ruletypeout Rule type for example list creation, list creation and
1311 * exception, list modification and so on.
1312 * @param ruledescriptionout Rule description.
1313 * @param conditiondescriptionsout Condition descriptions for the conditions
1314 * that are used in the input rule.
1315 * @param approvaltypenameout Action type names corresponding to the actions
1316 * that are used in the input rule
1317 * @param approvaltypedescriptionout These are action type descriptions
1318 * corresponding to the actions that are used in the input rule.
1319 * @param approvaldescriptionout These are action descriptions corresponding to
1320 * the actions that are used in the input rule.
1321 * @rep:displayname Get Rule Details 2
1322 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1323 * @rep:lifecycle active
1324 * @rep:scope public
1325 */
1326 --
1327 -- {End Of Comments}
1328 --
1329 procedure getRuleDetails2(ruleIdIn in integer,
1330 ruleTypeOut out nocopy varchar2,
1331 ruleDescriptionOut out nocopy varchar2,
1332 conditionDescriptionsOut out nocopy ame_util.longestStringList,
1333 approvalTypeNameOut out nocopy varchar2,
1334 approvalTypeDescriptionOut out nocopy varchar2,
1335 approvalDescriptionOut out nocopy varchar2);
1336 --
1337 -- ----------------------------------------------------------------------------
1338 -- |-----------------------------< getruledetails3 >--------------------------|
1339 -- ----------------------------------------------------------------------------
1340 --
1341 -- {Start Of Comments}
1342 /*#
1343 * This API gets the various rule details including the primary key and
1344 * description of the condition.
1345 *
1346 * This API has the same functionality as getRuleDetails1, but it outputs
1350 * ame_api.getRuleDetails2.
1347 * condition ID and descriptions, and indicates whether each condition has a
1348 * list of allowed values. Note : This API is a alternative for
1349 * ame_api3.getRuleDetails3. See also ame_api.getRuleDetails1 and
1351 *
1352 * <p><b>Licensing</b><br>
1353 * This API is available for use with any licensed component of the e-business
1354 * suite.
1355 *
1356 * <p><b>Prerequisites</b><br>
1357 * No known prerequisites.
1358 *
1359 * <p><b>Post Success</b><br>
1360 * The API will return the rule details in the various out parameters.
1361 *
1362 * <p><b>Post Failure</b><br>
1363 * The API will raise an error.
1364 *
1365 * @param ruleidin Rule id.
1366 * @param ruletypeout Rule type, for example list creation, list creation and
1367 * exception, list modification and so on.
1368 * @param ruledescriptionout Rule description.
1369 * @param conditionidsout Condition ids for the conditions that are used in the
1370 * input rule.
1371 * @param conditiondescriptionsout Condition descriptions corresponding to the
1372 * condition ids that are used in the input rule.
1373 * @param conditionhaslovsout This indicates whether the corresponding
1374 * condition has a list of allowed values
1375 * @param approvaltypenameout These are action type names corresponding to the
1376 * actions that are used in the input rule.
1377 * @param approvaltypedescriptionout Action type descriptions corresponding to
1378 * the actions that are used in the input rule
1379 * @param approvaldescriptionout These are action descriptions corresponding to
1380 * the actions that are used in the input rule.
1381 * @rep:displayname Get Rule Details 3
1382 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1383 * @rep:lifecycle active
1384 * @rep:scope public
1385 */
1386 --
1387 -- {End Of Comments}
1388 --
1389 procedure getRuleDetails3(ruleIdIn in integer,
1390 ruleTypeOut out nocopy varchar2,
1391 ruleDescriptionOut out nocopy varchar2,
1392 conditionIdsOut out nocopy ame_util.idList,
1393 conditionDescriptionsOut out nocopy ame_util.longestStringList,
1394 conditionHasLOVsOut out nocopy ame_util.charList,
1395 /* Each value is ame_util.booleanTrue or ame_util.booleanFalse. */
1396 approvalTypeNameOut out nocopy varchar2,
1397 approvalTypeDescriptionOut out nocopy varchar2,
1398 approvalDescriptionOut out nocopy varchar2);
1399 --
1400 -- ----------------------------------------------------------------------------
1401 -- |-----------------------------< initializeApprovalProcess >-----------------|
1402 -- ----------------------------------------------------------------------------
1403 --
1404 -- {Start Of Comments}
1405 /*#
1406 * The initializeApprovalProcess procedure causes AME's engine to
1407 * prepare a transaction's approval process, if it has not already
1408 * done so.
1409 *
1410 * <p><b>Licensing</b><br>
1411 * This API is available for use with any licensed component of the e-business
1412 * suite.
1413 *
1414 * <p><b>Prerequisites</b><br>
1415 * The transaction must not have been initiated already.
1416 *
1417 * <p><b>Post Success</b><br>
1418 * The transaction approval process will be initiated.
1419 *
1420 * <p><b>Post Failure</b><br>
1421 * The API will raise an error.
1422 *
1423 * @param applicationidin The fnd_application.application_id value of the
1424 * originating application calling the AME API routine.
1425 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1426 * transaction within a transaction type. Its value must not contain
1427 * white-space characters, and must not be the character representation of a
1428 * negative integer.
1429 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1430 * distinguishes one transaction type from another, within a given originating
1431 * application. It can be null, but you must always pass its value explicitly.
1432 * @param recordApproverListIn This flag specifies whether to record the approval
1433 * list or not.
1434 * @rep:displayname Initialize Approval Process
1435 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1436 * @rep:lifecycle active
1437 * @rep:scope public
1438 */
1439 --
1440 -- {End Of Comments}
1441 --
1442 procedure initializeApprovalProcess(applicationIdIn in integer,
1443 transactionIdIn in varchar2,
1444 transactionTypeIn in varchar2 default null,
1445 recordApproverListIn in boolean default false);
1446 --
1447 -- ----------------------------------------------------------------------------
1448 -- |------------------------------< insertapprover >--------------------------|
1449 -- ----------------------------------------------------------------------------
1450 --
1451 -- {Start Of Comments}
1452 /*#
1453 * Dynamically inserts an approver with a given insertion-order
1454 * relation at a given position in the transaction's current approver
1455 * list.
1456 *
1457 * <p><b>Licensing</b><br>
1458 * This API is available for use with any licensed component of the e-business
1459 * suite.
1460 *
1461 * <p><b>Prerequisites</b><br>
1462 * 1. The approval_status field of approverIn is null.
1466 *
1463 * 2. The combination of values in orderIn, the api_insertion field
1464 * of approverIn, and the authority field of approverIn match a
1465 * record returned by getAvailableInsertions.
1467 *
1468 * <p><b>Post Success</b><br>
1469 * The approver will be inserted in the transaction's current approver list.
1470 *
1471 * <p><b>Post Failure</b><br>
1472 * The API will raise an error.
1473 *
1474 * @param applicationidin The fnd_application.application_id value of the
1475 * originating application calling the AME API routine.
1476 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1477 * transaction within a transaction type. Its value must not contain
1478 * white-space characters, and must not be the character representation of a
1479 * negative integer.
1480 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1481 * distinguishes one transaction type from another, within a given originating
1482 * application. It can be null, but you must always pass its value explicitly.
1483 * @param approverIn This is the approverRecord defined by ame_util.approverRecord
1484 * which gives information regarding the Approver.
1485 * @param positionIn This specifies the index in the approver list where the insertion
1486 * is to be performed.
1487 * @param orderIn This is the record defined by ame_util.orderRecord which indicates the
1488 * order of insertion.
1489 * @rep:displayname Insert Approver
1490 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1491 * @rep:lifecycle active
1492 * @rep:scope public
1493 */
1494 --
1495 -- {End Of Comments}
1496 --
1497 procedure insertApprover(applicationIdIn in integer,
1498 transactionIdIn in varchar2,
1499 approverIn in ame_util.approverRecord,
1500 positionIn in integer,
1501 orderIn in ame_util.orderRecord,
1502 transactionTypeIn in varchar2 default null);
1503 --
1504 -- ----------------------------------------------------------------------------
1505 -- |-----------------------------< setFirstAuthorityApprover >-----------------|
1506 -- ----------------------------------------------------------------------------
1507 --
1508 -- {Start Of Comments}
1509 /*#
1510 * The setFirstAuthorityApprover procedure sets the first approver
1511 * for each chain of authority in the input transaction's approver
1512 * list. Thus if the approver list includes several chains of authority,
1513 * they will all start with approverIn.
1514 *
1515 * <p><b>Licensing</b><br>
1516 * This API is available for use with any licensed component of the e-business
1517 * suite.
1518 *
1519 * <p><b>Prerequisites</b><br>
1520 * 1. The approval_status field of approverIn is null.
1521 * 2. No chain-of-authority approver in the approver list has a
1522 * non-null approval_status value.
1523 *
1524 * <p><b>Post Success</b><br>
1525 * The first approver for each chain of authority will be set the given approver in
1526 * the given transaction's approver list.
1527 *
1528 * <p><b>Post Failure</b><br>
1529 * The API will raise an error.
1530 *
1531 * @param applicationidin The fnd_application.application_id value of the
1532 * originating application calling the AME API routine.
1533 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1534 * transaction within a transaction type. Its value must not contain
1535 * white-space characters, and must not be the character representation of a
1536 * negative integer.
1537 * @param approverIn This is the approverRecord defined by ame_util.approverRecord
1538 * which gives information regarding the Approver.
1539 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1540 * distinguishes one transaction type from another, within a given originating
1541 * application. It can be null, but you must always pass its value explicitly.
1542 *
1543 * @rep:displayname Set First Authority Approver
1544 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1545 * @rep:lifecycle active
1546 * @rep:scope public
1547 */
1548 --
1549 -- {End Of Comments}
1550 --
1551
1552 procedure setFirstAuthorityApprover(applicationIdIn in integer,
1553 transactionIdIn in varchar2,
1554 approverIn in ame_util.approverRecord,
1555 transactionTypeIn in varchar2 default null);
1556 --
1557 -- ----------------------------------------------------------------------------
1558 -- |---------------------------< updateapprovalstatus >-----------------------|
1559 -- ----------------------------------------------------------------------------
1560 --
1561 -- {Start Of Comments}
1562 /*#
1563 * This API updates an approver's approval status.
1564 * Updates an approver's status (to the approval_status value in
1565 * approverIn); and, if the approval_status value indicates that a
1566 * forwarding has occurred, identifies the forwardee. However, if
1567 * the approval_status value is ame_util.clearExceptionsStatus, the
1568 * procedure clears the transaction's exception log in AME, without
1569 * changing any approver's status, regardless of the approver
1570 * identified by approverIn.
1571 * When a chain-of-authority approver forwards, AME makes the
1572 * forwardee also a chain-of-authority approver. Otherwise, the
1576 * <p><b>Licensing</b><br>
1573 * forwardee has the api_insertion value ame_util.apiInsertion, and
1574 * the same authority value as the forwarder.
1575 *
1580 * <p><b>Prerequisites</b><br>
1577 * This API is available for use with any licensed component of the e-business
1578 * suite.
1579 *
1581 * 1. The approver should exist in the transaction's approver list.
1582 * 2. The status of the approver in the transaction's approver list must be notified.
1583 *
1584 * <p><b>Post Success</b><br>
1585 * The status of the given approver will be updated with the specified status.
1586 *
1587 * <p><b>Post Failure</b><br>
1588 * The API will raise an error.
1589 *
1590 * @param applicationidin The fnd_application.application_id value of the
1591 * originating application calling the AME API routine.
1592 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1593 * transaction within a transaction type. Its value must not contain
1594 * white-space characters, and must not be the character representation of a
1595 * negative integer.
1596 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1597 * distinguishes one transaction type from another, within a given originating
1598 * application. It can be null, but you must always pass its value explicitly.
1599 * @param approverIn This is the approverRecord defined by ame_util.approverRecord
1600 * which gives information regarding the Approver.
1601 * @param forwardeeIn Approver record of the forwardee if forwarding has been done.
1602 * @rep:displayname Update Approval Status
1603 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1604 * @rep:lifecycle active
1605 * @rep:scope public
1606 */
1607 --
1608 -- {End Of Comments}
1609 --
1610 procedure updateApprovalStatus(applicationIdIn in integer,
1611 transactionIdIn in varchar2,
1612 approverIn in ame_util.approverRecord,
1613 transactionTypeIn in varchar2 default null,
1614 forwardeeIn in ame_util.approverRecord default ame_util.emptyApproverRecord);
1615 --
1616 -- ----------------------------------------------------------------------------
1617 -- |--------------------------< updateapprovalstatus2 >-----------------------|
1618 -- ----------------------------------------------------------------------------
1619 --
1620 -- {Start Of Comments}
1621 /*#
1622 * This is a wrapper for updateApprovalStatus that lets you
1623 * identify an approver by person ID or user ID, rather than passing
1624 * an entire ame_util.approverRecord to the API.
1625 *
1626 * <p><b>Licensing</b><br>
1627 * This API is available for use with any licensed component of the e-business
1628 * suite.
1629 *
1630 * <p><b>Prerequisites</b><br>
1631 * 1. The approver should exist in the transaction's approver list.
1632 * 2. The status of the approver in the transaction's approver list must be notified.
1633 *
1634 * <p><b>Post Success</b><br>
1635 * The status of the given approver will be updated with the specified status.
1636 *
1637 * <p><b>Post Failure</b><br>
1638 * The API will raise an error.
1639 *
1640 * @param applicationidin The fnd_application.application_id value of the
1641 * originating application calling the AME API routine.
1642 * @param transactionidin This is a string up to 50 bytes long. It identifies a
1643 * transaction within a transaction type. Its value must not contain
1644 * white-space characters, and must not be the character representation of a
1645 * negative integer.
1646 * @param transactiontypein This is a string parameter up to 50 bytes long. It
1647 * distinguishes one transaction type from another, within a given originating
1648 * application. It can be null, but you must always pass its value explicitly.
1649 * @param approvalStatusIn This specifies the status to be updated.
1650 * @param approverPersonIdIn This specifies the person id of the approver.
1651 * @param approverUserIdIn This specifies the user id of the approver.
1652 * @param forwardeeIn This is the record specified by ame_util.approverRecord
1653 * that represents the approver to whom forwarding has been done.
1654 * @param approvalTypeIdIn This specifies the type of the approver.
1655 * @param groupOrChainIdIn This specifies the id of the Group or the chain
1656 * to which the approver belongs to.
1657 * @param occurrenceIn This represents the Occurrence of the approver in the
1658 * approver list of a particular item.
1659 * @rep:displayname Update Approval Status 2
1660 * @rep:category BUSINESS_ENTITY AME_APPROVAL
1661 * @rep:lifecycle active
1662 * @rep:scope public
1663 */
1664 --
1665 -- {End Of Comments}
1666 --
1667 procedure updateApprovalStatus2(applicationIdIn in integer,
1668 transactionIdIn in varchar2,
1669 approvalStatusIn in varchar2,
1670 approverPersonIdIn in integer default null,
1671 approverUserIdIn in integer default null,
1672 transactionTypeIn in varchar2 default null,
1673 forwardeeIn in ame_util.approverRecord default ame_util.emptyApproverRecord,
1674 approvalTypeIdIn in integer default null,
1675 groupOrChainIdIn in integer default null,
1676 occurrenceIn in integer default null);
1677 end ame_api;
[Home] [Help]