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.WF_ENGINE_UTIL dependencies on WF_ITEM_ACTIVITY_STATUS

Line 233: SELECT /+ leading(wias) index(wias,WF_ITEM_ACTIVITY_STATUSES_PK) /

229: -- The join to active rows in WAIS for this item should choose
230: -- exactly one of these.
231:
232: -- bug 1663684 - Added hint to choose a different driving table
233: SELECT /*+ leading(wias) index(wias,WF_ITEM_ACTIVITY_STATUSES_PK) */
234: WPA.INSTANCE_ID
235: INTO parentid
236: FROM WF_ITEM_ACTIVITY_STATUSES WIAS,
237: WF_PROCESS_ACTIVITIES WPA

Line 236: FROM WF_ITEM_ACTIVITY_STATUSES WIAS,

232: -- bug 1663684 - Added hint to choose a different driving table
233: SELECT /*+ leading(wias) index(wias,WF_ITEM_ACTIVITY_STATUSES_PK) */
234: WPA.INSTANCE_ID
235: INTO parentid
236: FROM WF_ITEM_ACTIVITY_STATUSES WIAS,
237: WF_PROCESS_ACTIVITIES WPA
238: WHERE WPA.ACTIVITY_ITEM_TYPE =
239: WF_CACHE.ProcessActivities(actid).PROCESS_ITEM_TYPE
240: AND WPA.ACTIVITY_NAME = WF_CACHE.ProcessActivities(actid).PROCESS_NAME

Line 376: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

372: lresult := result;
373: end if;
374:
375: -- Update the item activity status
376: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
377: wf_engine.eng_completed, lresult, '', SYSDATE);
378:
379: if (acttype = wf_engine.eng_process) then
380: -- If this activity is a process, kill any deferred children.

Line 389: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey, actid,

385: elsif (acttype = wf_engine.eng_notification) then
386: -- Cancel any outstanding notifications for this activity if
387: -- a response is expected.
388: -- (Response expected is signalled by a non-null result)
389: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey, actid,
390: notid, user);
391: if ((notid is not null) and (lresult <> wf_engine.eng_null)) then
392: begin
393: Wf_Notification.CancelGroup(gid=>notid, timeout=>TRUE);

Line 417: Wf_Item_Activity_Status.Status(itemtype, itemkey,

413: -- 2. avoid creating confusing COMPLETE/#FORCE rows in process_activity
414: -- for activities following this one.
415: -- SYNCHMODE: No need to check, parent must always be active.
416: if (itemkey <> wf_engine.eng_synch) then
417: Wf_Item_Activity_Status.Status(itemtype, itemkey,
418: Wf_Engine_Util.Activity_Parent_Process(itemtype, itemkey, actid),
419: parent_status);
420: if (parent_status in (wf_engine.eng_completed, wf_engine.eng_error)) then
421: return;

Line 659: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, processid,

655: Wf_Core.Token('NAME', process);
656: Wf_Core.Raise('WFENG_PROCESS_RUNNABLE');
657: end if;
658:
659: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, processid,
660: wf_engine.eng_active, wf_engine.eng_null, SYSDATE, null,
661: newStatus=>TRUE);
662:
663: -- Initialize process call stack with the root process.

Line 822: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),

818: -- For runmode modes, just mark starters as NOTIFIED,
819: -- and thus ready for external input, but don't actually run
820: -- them. Only the start activities matching the specific
821: -- activity/event will be run (below).
822: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),
823: wf_engine.eng_notified, wf_engine.eng_null, SYSDATE, null,
824: newStatus=>TRUE);
825: elsif (defer_mode) then
826: -- Insert child rows as deferred with no further processing

Line 827: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),

823: wf_engine.eng_notified, wf_engine.eng_null, SYSDATE, null,
824: newStatus=>TRUE);
825: elsif (defer_mode) then
826: -- Insert child rows as deferred with no further processing
827: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),
828: wf_engine.eng_deferred, wf_engine.eng_null, SYSDATE, null,
829: newStatus=>TRUE);
830: else -- Must be START mode, and not deferred
831: -- Process start activity normally

Line 845: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey,

841: exception
842: when trig_savepoint or dist_savepoint then
843: -- Oops, you forgot to defer your trigger or distributed
844: -- transaction initiated process! I'll do it for you.
845: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey,
846: childarr(i), wf_engine.eng_deferred, wf_engine.eng_null,
847: SYSDATE, null, newStatus=>TRUE);
848: when others then
849: -- If anything in this process raises an exception:

Line 856: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, processid,

852: -- 3. execute the error process (if any)
853: -- 4. clear the error to continue with next activity
854: rollback to wf_savepoint;
855: Wf_Core.Context('Wf_Engine', 'Start_Process_Internal', itemtype, itemkey);
856: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, processid,
857: wf_engine.eng_exception, FALSE);
858: Wf_Engine_Util.Execute_Error_Process(itemtype, itemkey, processid,
859: wf_engine.eng_exception);
860: Wf_Core.Clear;

Line 951: Wf_Item_Activity_Status.Status(itemtype, itemkey,

947:
948: -- Check this activity's parent process
949: -- SYNCHMODE: No need to check parent, will always be active.
950: if (itemkey <> wf_engine.eng_synch) then
951: Wf_Item_Activity_Status.Status(itemtype, itemkey,
952: Wf_Engine_Util.Activity_Parent_Process(itemtype, itemkey, actid),
953: status);
954:
955: if (status is null) then

Line 963: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

959: return;
960: elsif ((status = wf_engine.eng_completed) or
961: (status = wf_engine.eng_error)) then
962: -- Mark it as completed cause the parent process is completed/errored
963: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
964: wf_engine.eng_completed, wf_engine.eng_force, sysdate, sysdate);
965: return;
966:
967: elsif (status = wf_engine.eng_suspended) then

Line 969: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

965: return;
966:
967: elsif (status = wf_engine.eng_suspended) then
968: -- Insert this activity as deferred
969: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
970: wf_engine.eng_deferred, null,
971: sysdate, null, suspended=>TRUE);
972: return;
973: elsif (status in (wf_engine.eng_notified, wf_engine.eng_waiting,

Line 1003: Wf_Item_Activity_Status.Result(itemtype, itemkey, actid, status, result);

999: if (itemkey = wf_engine.eng_synch) then
1000: status := '';
1001: result := '';
1002: else
1003: Wf_Item_Activity_Status.Result(itemtype, itemkey, actid, status, result);
1004: if (status is not null) then
1005: if ( (status = wf_engine.eng_active) AND (activate = FALSE) )then
1006: -- Maybe don't have to do anything because it is running already
1007: return;

Line 1057: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

1053: -- except for a suspended process
1054:
1055: if (status is null ) then
1056: -- Insert this activity as active into the WIAS table
1057: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
1058: wf_engine.eng_active, null,
1059: sysdate, null, newStatus=>TRUE);
1060:
1061: elsif (status <> wf_engine.eng_suspended) then

Line 1062: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

1058: wf_engine.eng_active, null,
1059: sysdate, null, newStatus=>TRUE);
1060:
1061: elsif (status <> wf_engine.eng_suspended) then
1062: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
1063: wf_engine.eng_active, null,
1064: sysdate, null, newStatus=>FALSE);
1065: end if;
1066:

Line 1108: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey,

1104: -- transaction initiated process! I'll do it for you.
1105: -- (Note this is only needed here for restarting a
1106: -- process using CompleteActivity, all other will be caught
1107: -- by error handling savepoints before this.)
1108: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey,
1109: actid, wf_engine.eng_deferred, null,
1110: SYSDATE, null, newStatus=>TRUE);
1111: end;
1112: end if;

Line 1116: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

1112: end if;
1113: else
1114: -- Cost is over the threshold or this is a callout function
1115: -- Insert this activity into the WIAS table and mark it as deferred
1116: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
1117: wf_engine.eng_deferred, null,
1118: sysdate, null, newStatus=>TRUE);
1119: end if; -- end if deferred
1120:

Line 1196: Wf_Item_Activity_Status.Result(itemtype, itemkey, actid, status, result);

1192: watIND NUMBER;
1193: l_LinkCollision BOOLEAN;
1194:
1195: begin
1196: Wf_Item_Activity_Status.Result(itemtype, itemkey, actid, status, result);
1197:
1198: if (status is null) then
1199: return; -- This means the end of a path
1200: end if;

Line 1227: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey, actid,

1223: Wf_Engine_Util.Execute_Post_NTF_Function(itemtype, itemkey, actid,
1224: wf_engine.eng_cancel, pntfstatus, pntfresult);
1225:
1226: -- Cancel any open notifications sent by this activity
1227: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey, actid,
1228: notid, user);
1229: if (notid is not null) then
1230: begin
1231: Wf_Notification.CancelGroup(notid);

Line 1432: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, goalid,

1428: -- Goal has been found. Reset the activity and all following it on this
1429: -- level, then set status to waiting for possible re-execution.
1430: if (rootid = goalid) then
1431: Wf_Engine_Util.Reset_Activities(itemtype, itemkey, goalid, TRUE);
1432: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, goalid,
1433: wf_engine.eng_active, wf_engine.eng_null, sysdate, null);
1434: return(TRUE);
1435: end if;
1436:

Line 1451: Wf_Item_Activity_Status.Result(itemtype, itemkey, rootid,

1447: if (Wf_Engine_Util.Reset_Tree(itemtype, itemkey, childarr(i), goalid,
1448: actdate)) then
1449:
1450: -- Goal has been found in a child of this activity.
1451: Wf_Item_Activity_Status.Result(itemtype, itemkey, rootid,
1452: status, result);
1453:
1454: -- Reset any activities FOLLOWING the root.
1455: -- Do not reset the root itself - it is a process and its children

Line 1562: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, rootid,

1558: --
1559:
1560: -- Set the root activity status to active if not already
1561: if (nvl(status, 'x') <> wf_engine.eng_active) then
1562: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, rootid,
1563: wf_engine.eng_active, wf_engine.eng_null, sysdate, null);
1564: end if;
1565:
1566: -- Goal has been found, so exit now

Line 1584: -- Move the item activity status row from WF_ITEM_ACTIVITY_STATUSES to

1580: end Reset_Tree;
1581:
1582: --
1583: -- Move_To_History (PRIVATE)
1584: -- Move the item activity status row from WF_ITEM_ACTIVITY_STATUSES to
1585: -- WF_ITEM_ACTIVITY_STATUSES_H table.
1586: -- IN
1587: -- itemtype - A valid item type from (WF_ITEM_TYPES table).
1588: -- itemkey - A string generated from the application object's primary key.

Line 1585: -- WF_ITEM_ACTIVITY_STATUSES_H table.

1581:
1582: --
1583: -- Move_To_History (PRIVATE)
1584: -- Move the item activity status row from WF_ITEM_ACTIVITY_STATUSES to
1585: -- WF_ITEM_ACTIVITY_STATUSES_H table.
1586: -- IN
1587: -- itemtype - A valid item type from (WF_ITEM_TYPES table).
1588: -- itemkey - A string generated from the application object's primary key.
1589: -- actid - The activity instance id.

Line 1598: INSERT INTO WF_ITEM_ACTIVITY_STATUSES_H (

1594: begin
1595:
1596: -- Copy row to history table, changing status to COMPLETE/#FORCE
1597: -- if status is not already complete.
1598: INSERT INTO WF_ITEM_ACTIVITY_STATUSES_H (
1599: ITEM_TYPE,
1600: ITEM_KEY,
1601: PROCESS_ACTIVITY,
1602: ACTIVITY_STATUS,

Line 1636: FROM WF_ITEM_ACTIVITY_STATUSES

1632: ERROR_MESSAGE,
1633: ERROR_STACK,
1634: ACTION,
1635: PERFORMED_BY
1636: FROM WF_ITEM_ACTIVITY_STATUSES
1637: WHERE ITEM_TYPE = itemtype
1638: AND ITEM_KEY = itemkey
1639: AND PROCESS_ACTIVITY = actid;
1640:

Line 1644: -- INSERT INTO WF_ITEM_ACTIVITY_STATUSES_H (

1640:
1641: -- 3966635 Workflow Provisioning Project
1642: -- Insert added so as not to loose the change. This insert
1643: -- should replace the one above.
1644: -- INSERT INTO WF_ITEM_ACTIVITY_STATUSES_H (
1645: -- ITEM_TYPE,
1646: -- ITEM_KEY,
1647: -- PROCESS_ACTIVITY,
1648: -- ACTIVITY_STATUS,

Line 1684: --FROM WF_ITEM_ACTIVITY_STATUSES

1680: -- ERROR_STACK,
1681: -- ACTION,
1682: -- PERFORMED_BY,
1683: -- PROV_REQUEST_ID
1684: --FROM WF_ITEM_ACTIVITY_STATUSES
1685: --WHERE ITEM_TYPE = itemtype
1686: --AND ITEM_KEY = itemkey
1687: --AND PROCESS_ACTIVITY = actid;
1688:

Line 1693: Wf_Item_Activity_Status.Delete_Status(itemtype, itemkey, actid);

1689: if (Wf_Engine.Debug) then
1690: commit;
1691: end if;
1692:
1693: Wf_Item_Activity_Status.Delete_Status(itemtype, itemkey, actid);
1694:
1695: EXCEPTION
1696: when OTHERS then
1697: Wf_Core.Context('Wf_Engine_Util', 'Move_To_History', itemtype, itemkey,

Line 1766: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid,

1762: raise;
1763: elsif (funmode <> wf_engine.eng_cancel) then
1764: -- Set error info columns if activity function raised exception,
1765: -- unless running in cancel mode.
1766: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid,
1767: wf_engine.eng_exception, FALSE);
1768: result := wf_engine.eng_error||':'||wf_engine.eng_exception;
1769: end if;
1770: end;

Line 1790: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

1786: if (substr(result, 1, length(wf_engine.eng_error)) =
1787: wf_engine.eng_error) then
1788: -- Get the error code
1789: id := substr(result, length(wf_engine.eng_error)+2, 30);
1790: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
1791: wf_engine.eng_error, id);
1792:
1793: -- Call error_process to execute any error processes.
1794: Wf_Engine_Util.Execute_Error_Process(itemtype, itemkey, actid, id);

Line 1797: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

1793: -- Call error_process to execute any error processes.
1794: Wf_Engine_Util.Execute_Error_Process(itemtype, itemkey, actid, id);
1795:
1796: elsif (result = wf_engine.eng_waiting) then
1797: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
1798: wf_engine.eng_waiting, '', to_date(NULL), to_date(NULL));
1799:
1800: elsif (substr(result, 1, length(wf_engine.eng_deferred)) =
1801: wf_engine.eng_deferred) then

Line 1812: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

1808: end if;
1809:
1810: -- Set the status to 'DEFERRED', and reset the begin_date to the
1811: -- extracted resume_date if there is one.
1812: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
1813: wf_engine.eng_deferred, wf_engine.eng_null, resume_date,
1814: to_date(NULL));
1815:
1816: elsif (substr(result, 1, length(wf_engine.eng_notified)) =

Line 1829: Wf_Item_Activity_Status.Update_Notification(itemtype, itemkey, actid,

1825: -- Set notification id and user, but only if not null.
1826: -- This is to allow for pseudo-notifications that are only blocking
1827: -- waiting for external completion.
1828: if (nvl(id, wf_engine.eng_null) <> wf_engine.eng_null) then
1829: Wf_Item_Activity_Status.Update_Notification(itemtype, itemkey, actid,
1830: to_number(id), notuser);
1831: end if;
1832: end if;
1833:

Line 1850: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

1846:
1847: else
1848: -- Notification not auto-routed, or pseudo-notification.
1849: -- In either case, mark status NOTIFIED to block execution.
1850: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
1851: wf_engine.eng_notified, '', to_date(NULL),to_date(NULL));
1852: end if;
1853:
1854: else -- Assume COMPLETE

Line 2023: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid,

2019: if (Wf_Engine.context_nid is not null) then
2020: temp := null;
2021: else
2022: -- This is a real function. Set an error.
2023: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid,
2024: wf_engine.eng_noresult, FALSE);
2025: temp := wf_engine.eng_error||':'||wf_engine.eng_noresult;
2026: end if;
2027:

Line 2323: WF_ACTIVITIES A1, WF_ITEM_ACTIVITY_STATUSES WIAS

2319: cursor children_to_kill (pid in pls_integer) is
2320: SELECT
2321: WIAS.PROCESS_ACTIVITY, WIAS.ACTIVITY_STATUS
2322: FROM WF_PROCESS_ACTIVITIES PA, WF_PROCESS_ACTIVITIES PA1,
2323: WF_ACTIVITIES A1, WF_ITEM_ACTIVITY_STATUSES WIAS
2324: WHERE PA.INSTANCE_ID = pid
2325: AND PA.ACTIVITY_ITEM_TYPE = PA1.PROCESS_ITEM_TYPE
2326: AND PA.ACTIVITY_NAME = PA1.PROCESS_NAME
2327: AND PA1.PROCESS_VERSION = A1.VERSION

Line 2379: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey,

2375: -- If child is a process then recursively kill its children
2376: Wf_Engine_Util.Process_Kill_Children(itemtype, itemkey, childid);
2377: else
2378: -- Cancel any open notifications sent by this activity
2379: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey,
2380: childid, notid, user);
2381: if (notid is not null) then
2382: begin
2383: Wf_Notification.CancelGroup(notid,'');

Line 2401: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childid,

2397: itemtype , itemkey, childid));
2398: end if;
2399:
2400: -- Complete the activity with the force result
2401: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childid,
2402: wf_engine.eng_completed, wf_engine.eng_force, to_date(NULL),
2403: SYSDATE);
2404:
2405: -- No needs to check null type because this is internal function

Line 2435: FROM WF_ITEM_ACTIVITY_STATUSES WIAS, WF_PROCESS_ACTIVITIES WPA1,

2431: -- Select all the active children process(es) under this parent process
2432: cursor children_be_suspended(parent in pls_integer) is
2433: SELECT
2434: WIAS.PROCESS_ACTIVITY
2435: FROM WF_ITEM_ACTIVITY_STATUSES WIAS, WF_PROCESS_ACTIVITIES WPA1,
2436: WF_ACTIVITIES WA1, WF_PROCESS_ACTIVITIES WPA2, WF_ACTIVITIES WA2
2437: WHERE WPA1.INSTANCE_ID = processid
2438: AND WPA1.ACTIVITY_ITEM_TYPE = WA1.ITEM_TYPE
2439: AND WPA1.ACTIVITY_NAME = WA1.NAME

Line 2472: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),

2468:
2469: -- While loop to handle all the children processes
2470: i := 0;
2471: while (childarr(i) is not null) loop
2472: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),
2473: wf_engine.eng_suspended, null, to_date(NULL), SYSDATE);
2474: suspend_child_processes(itemtype, itemkey, childarr(i));
2475: i := i + 1;
2476: end loop;

Line 2503: FROM WF_ITEM_ACTIVITY_STATUSES WIAS, WF_PROCESS_ACTIVITIES WPA1,

2499: -- Select all the suspended children processes under this parent process
2500: cursor children_be_resumed(parent in pls_integer) is
2501: SELECT
2502: WIAS.PROCESS_ACTIVITY
2503: FROM WF_ITEM_ACTIVITY_STATUSES WIAS, WF_PROCESS_ACTIVITIES WPA1,
2504: WF_PROCESS_ACTIVITIES WPA2, WF_ACTIVITIES WA
2505: WHERE WPA1.INSTANCE_ID = processid
2506: AND WPA1.ACTIVITY_ITEM_TYPE = WA.ITEM_TYPE
2507: AND WPA1.ACTIVITY_NAME = WA.NAME

Line 2536: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),

2532:
2533: -- While loop to handle all the children processes
2534: i := 0;
2535: while (childarr(i) is not null) loop
2536: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, childarr(i),
2537: wf_engine.eng_active, null, null, SYSDATE);
2538: resume_child_processes(itemtype, itemkey, childarr(i));
2539: i := i + 1;
2540: end loop;

Line 2647: duedate := Wf_Item_Activity_Status.Due_Date(itemtype, itemkey, actid);

2643: -- Construct context as itemtype:key:actid
2644: ctx := itemtype||':'||itemkey||':'||to_char(actid);
2645:
2646: -- Mark duedate of notification as timeout date of activity
2647: duedate := Wf_Item_Activity_Status.Due_Date(itemtype, itemkey, actid);
2648:
2649: -- Check for #PRIORITY activity attribute to override default
2650: -- priority of this notification
2651: begin

Line 2703: Wf_Item_Activity_Status.Update_Notification(itemtype, itemkey, actid,

2699: exception
2700: when no_data_found then
2701: -- No respond attributes.
2702: -- Set notification id, then complete immediately.
2703: Wf_Item_Activity_Status.Update_Notification(itemtype, itemkey, actid,
2704: notid, performer);
2705: result := Wf_Engine.Eng_Null;
2706: end;
2707:

Line 2875: from wf_item_activity_statuses_h ias,

2871: cursor message_attrs_cursor(itemtype varchar2, itemkey varchar2) is
2872: select ma.NAME, ma.TYPE, ma.SUBTYPE,
2873: ma.TEXT_DEFAULT, ma.NUMBER_DEFAULT, ma.DATE_DEFAULT,
2874: n.notification_id
2875: from wf_item_activity_statuses_h ias,
2876: wf_notifications n,
2877: wf_message_attributes ma
2878: where ias.item_type = itemtype
2879: and ias.item_key = itemkey

Line 3026: wf_item_activity_status.notification_status(itemtype, itemkey, actid,

3022: wf_engine.SetItemParent(errortype, errkey, itemtype, itemkey,
3023: to_char(actid));
3024:
3025: -- Select and set pre-defined error attributes.
3026: wf_item_activity_status.notification_status(itemtype, itemkey, actid,
3027: notid, user);
3028: label := Wf_Engine.GetActivityLabel(actid);
3029:
3030: wf_item_activity_status.error_info(itemtype, itemkey, actid,

Line 3030: wf_item_activity_status.error_info(itemtype, itemkey, actid,

3026: wf_item_activity_status.notification_status(itemtype, itemkey, actid,
3027: notid, user);
3028: label := Wf_Engine.GetActivityLabel(actid);
3029:
3030: wf_item_activity_status.error_info(itemtype, itemkey, actid,
3031: errname, errmsg, errstack);
3032:
3033: -- look up the monitor URL
3034: err_url := WF_MONITOR.GetEnvelopeURL

Line 3075: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid, '', TRUE);

3071: when others then
3072: -- If an error is raised in error process, do NOT raise another exception.
3073: -- Append the new error to the original error in WIAS error columns,
3074: -- then clear and ignore the exception.
3075: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid, '', TRUE);
3076: Wf_Core.Clear;
3077: end Execute_Error_Process;
3078:
3079: --

Line 3166: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey, actid,

3162: /* Bug 2156047 */
3163: -- Set global context areas.
3164: -- This is context information for use by post ntf function
3165: -- when executing in modes RUN, RESPOND, TRANSFER etc.
3166: Wf_Item_Activity_Status.Notification_Status(itemtype, itemkey, actid,
3167: l_notid, l_responder);
3168: Wf_Engine.context_nid := l_notid;
3169: Wf_Engine.context_text := l_responder;
3170:

Line 3181: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid,

3177: -- Set error info columns if post-notification function raised exception,
3178: -- unless running in cancel mode.
3179: when others then
3180: if (funmode <> wf_engine.eng_cancel) then
3181: Wf_Item_Activity_Status.Set_Error(itemtype, itemkey, actid,
3182: wf_engine.eng_exception, FALSE);
3183: result := wf_engine.eng_error||':'||wf_engine.eng_exception;
3184: end if;
3185: end;

Line 3208: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,

3204: elsif (substr(result, 1, length(wf_engine.eng_error)) =
3205: wf_engine.eng_error) then
3206: -- Get the error code
3207: errcode := substr(result, length(wf_engine.eng_error)+2, 30);
3208: Wf_Item_Activity_Status.Create_Status(itemtype, itemkey, actid,
3209: wf_engine.eng_error, errcode);
3210:
3211: -- Call error_process to execute any error processes.
3212: Wf_Engine_Util.Execute_Error_Process(itemtype, itemkey, actid, errcode);