[Home] [Help]
The following lines contain the word 'select', 'insert', 'update' or 'delete':
| 27-Feb-2002 cjang Added can_update_task, get_max_enddate |
| Modified add_task |
| 28-Feb-2002 cjang Integrate with invitee function |
| 01-Mar-2002 cjang Refactoring and Bug Fix |
| 06-Mar-2002 cjang Added get_all_nonrepeat_tasks |
| get_all_repeat_tasks |
| create_new_data |
| update_existing_data |
| add_nonrepeat_task |
| add_repeat_task |
| Modified parameters on add_task |
| 08-Mar-2002 arpatel Added all attributes for update of |
| repeating appointments |
| 11-Mar-2002 cjang Added the followings |
| - delete_exclusion_task |
| - delete_task_data |
| - reject_task_data |
| - changed_repeat_rule |
| - update_repeating_rule |
| 11-Mar-2002 sanjeev - changed methods for exclusions |
| - changed update_existing_data() |
| 13-Mar-2002 cjang Added insert_or_update_mapping |
| Changed OUT to IN OUT on the parameter |
| x_task_rec in delete_exclusion_task |
| 14-Mar-2002 arpatel Added privateFlag to create_new_data |
| and update_existing_data |
| 14-Mar-2002 ssallaka Added get_exclusion _data |
| 15-Mar-2002 ssallaka Added count_exclusion |
| 25-Mar-2002 sanjeev Added procedure transformStatus() |
| function getChangedStatusId() and |
| checkUserStatusRule() |
| 04-Apr-2002 cjang Modified convert_recur_date_to_client |
| TO_DATE should only use numbers |
| 08-Apr-2002 arpatel Merged convert_dates2 with convert_dates |
| 09-APr-2002 ssallaka Choping the subject of task if it is |
| more than 80 chars and fixed the typo |
| of tuesday in task_rec |
| 19-Apr-2002 cjang Removed p_get_data from add_task() |
| 24-Apr-2002 cjang Process exclusion first, and update |
| 25-Apr-2002 cjang Modified update_existing_data() to fix |
| the length(80) issue of task name |
| Modified get_all_deleted_tasks to execute |
| the new cursor c_delete_assignee_reject |
| to pick up the appts rejected by assignee|
| 26-Apr-2002 cjang Modified all the calls to check_span_days |
| to pass source_object_type_code |
| rather than p_request_type |
| All delete cursor has now p_resource_type |
| 30-Apr-2002 cjang Added a new parameter p_resource_type |
| in get_assignment_id |
| Fixed the undefined message name |
| 01-May-2002 cjang Fixed task_name length issue |
| Added convert_carriage_return |
| Modified get_subject |
| 17-May-2002 cjang Fix for the bug 2380399 |
| Modified update_existing_data() |
| 21-May-2002 cjang Modified get_exclusion_data() |
| Added "DISTINCT" in the cursor c_exclusion|
| 23-May-2002 cjang Modified add_task() to fix bug 2389092 |
| it defaults x_task_rec.dateselected with |
| 'S' when it's NULL. |
| Added validate_syncid() to fix bug 2382927 |
| 29-May-2002 cjang Modified validate_syncid() |
| to fix Bug# 2395004 |
| |
| 02-Jul-2002 cjang (Fix Bug: 2442686) Ver: 115.75 |
| If this is TASK, assignee can update any |
| fields, but if it's APPOINTMENT, then |
| the invitee can update only the status when|
| he/she accept the appointment. |
| Modified get_update_type() |
| to check source object type code when the|
| login user is an assignee for the task |
| |
| (Fix Bug: 2443049) Ver: 115.76 |
| When a new task is synced from Outlook, |
| display on calendar should be checked. |
| When a updated task is synced from Outlook,|
| display on calendar should not be nullified|
| 04-Oct-2002 cjang To fix bug 2540722, |
| in ADD_TASK() |
| 1) Change local varible definition |
| from l_category_name VARCHAR2(40); |
| 2) Modified get_all_deleted_tasks |
| 3) Modified get_all_repeat_tasks |
| 4) Added already_selected() |
| Fixed bug 2482833 |
| 1) Added get_sync_info() |
| 2) Modified get_update_type() |
| Fixed GSCC Warning |
| File.Pkg.22 |
| 1190-1, 1511, 2527, 3144 - |
| No default parameter values in package body|
| 09-Oct-2002 cjang Fixed bug 2467021 |
| Modified convert_dates(),create_new_data(),update_existing_data():
| If it is APPOINTMENT, pass Y for show_on_calendar and pass P for date_selected.
| This is coded by the package jta_cal_appointment_pvt.
| If it is TASK for creation, pass show_on_calendar and date_selected as NULL
| if it is TASK for update, pass show_on_calendar and date_selected as g_miss_char
| 22-Oct-2002 cjang Fixed bug 2635512, Removed debug_pkg.add |
| 01-Nov-2002 cjang Fixed bug 2540722 |
| Call jtf_task_security_pvt.get_category_id()|
| and jtf_task_utl.get_category_name() |
| instead of calling jtf_task_utl.get_category_name_for_task()
| 07-Nov-2002 cjang Removed the code fix for the bug 2469488, |
| 2469487, 2469479 |
| But keep the function already_selected() |
| so this version 115.82 is basically |
| same as 115.81 |
| Here just removed the comment |
| "Fixed bug 2469488, 2469487, 2469479" |
*=======================================================================*/
PROCEDURE check_span_days (
p_source_object_type_code IN VARCHAR2,
p_calendar_start_date IN DATE,
p_calendar_end_date IN DATE,
x_status OUT NOCOPY BOOLEAN
)
IS
BEGIN
-------------------------------------------
-- Returns TRUE:
-- 1) if an appointment spans over a day
-- 2) if a task is endless
-------------------------------------------
x_status := FALSE;
delete_exclusion_task (
p_repeating_task_id => l_exclude_task_id,
x_task_rec => p_task_rec
);
SELECT task_id
FROM jta_sync_task_mapping
WHERE task_sync_id = p_sync_id;
SELECT COUNT (recurrence_rule_id)
INTO l_count
FROM jta_task_exclusions
WHERE recurrence_rule_id = p_recurrence_rule_id;
SELECT COUNT (recurrence_rule_id)
INTO l_count
FROM jtf_tasks_b
WHERE recurrence_rule_id = p_recurrence_rule_id;
SELECT task_id
FROM jtf_tasks_b
WHERE recurrence_rule_id = b_recurrence_rule_id
AND TRUNC (calendar_start_date) = TRUNC (b_exclusion_start_date);
l_date_selected VARCHAR2(1);
CURSOR c_dateselect
IS
SELECT jt.date_selected
FROM jtf_tasks_b jt
WHERE jt.task_id = p_task_id;
OPEN c_dateselect;
FETCH c_dateselect INTO l_date_selected;
IF c_dateselect%NOTFOUND
OR l_date_selected = 'P'
OR p_request_type = G_REQ_APPOINTMENT
THEN
l_date := p_planned_start_date;
ELSIF l_date_selected = 'S'
THEN
l_date := p_scheduled_start_date;
ELSIF l_date_selected = 'A'
THEN
l_date := p_actual_start_date;
CLOSE c_dateselect;
SELECT task_id
FROM jta_sync_task_mapping
WHERE task_sync_id = p_sync_id;
SELECT task_id
FROM jtf_task_all_assignments
WHERE task_assignment_id = p_task_assignment_id;
SELECT timezone_id
FROM jtf_tasks_b
WHERE task_id = p_task_id;
SELECT object_version_number
FROM jtf_tasks_b
WHERE task_id = b_task_id;
SELECT object_version_number
FROM jtf_task_all_assignments
WHERE task_assignment_id = b_task_assignment_id;
SELECT resource_id, 'RS_' || category
FROM jtf_rs_resource_extns
WHERE user_id = fnd_global.user_id;
SELECT jta_sync_task_mapping_s.nextval
INTO x_task_sync_id
FROM dual;
jta_sync_task_map_pkg.insert_row (
p_task_sync_id => x_task_sync_id,
p_task_id => p_task_id,
p_resource_id => jta_sync_task.g_login_resource_id
);
jta_sync_task_map_pkg.update_row (
p_task_sync_id => x_task_sync_id,
p_task_id => p_task_id,
p_resource_id => jta_sync_task.g_login_resource_id
);
/* ELSIF p_operation = G_DELETE
THEN
jta_sync_task_map_pkg.delete_row (
p_task_sync_id => x_task_sync_id
);*/
p_deleted_flag IN VARCHAR2,
p_task_sync_id IN NUMBER,
p_source_object_type_code IN VARCHAR2,
p_calendar_start_date IN DATE,
p_calendar_end_date IN DATE,
p_assignment_status_id IN NUMBER,
x_operation OUT NOCOPY VARCHAR2
)
IS
l_deleted_flag VARCHAR2(1) := NVL (p_deleted_flag, 'N');
x_operation := G_DELETE;
IF l_deleted_flag = 'Y' OR
p_assignment_status_id = 4 -- Rejected
THEN
x_operation := G_DELETE;
ELSE -- l_deleted_flag = 'N'
x_operation := G_MODIFY;
IF l_deleted_flag = 'N' AND
nvl(p_assignment_status_id,-1) <> 4 -- Not Rejected
THEN
x_operation := G_NEW;
SELECT group_id resource_id
FROM jtf_rs_group_members
WHERE resource_id = b_resource_id
AND delete_flag <> 'Y';
SELECT team_id resource_id
FROM jtf_rs_team_members
WHERE team_resource_id = b_resource_id
AND delete_flag <> 'Y';
SELECT DISTINCT fgs.instance_pk1_value resource_id,
fgs.instance_pk2_value resource_type
FROM fnd_grants fgs,
fnd_menus fmu,
fnd_objects fos,
jtf_rs_group_usages jru,
jtf_rs_groups_tl jrt
WHERE fgs.object_id = fos.object_id -- grants joint to object
AND fgs.menu_id = fmu.menu_id -- grants joint to menus
AND fos.obj_name = 'JTF_TASK_RESOURCE'
AND fgs.grantee_key = b_resource_id
AND fgs.grantee_type = 'USER'
AND fgs.start_date < SYSDATE
AND ( fgs.end_date >= SYSDATE
OR fgs.end_date IS NULL)
AND fgs.instance_pk2_value = 'RS_GROUP'
AND jrt.group_id = TO_NUMBER (fgs.instance_pk1_value)
AND jrt.language = USERENV ('LANG')
AND jru.group_id = jrt.group_id
AND jru.usage = 'GROUP_CALENDAR';
p_operation IN VARCHAR2, --CREATE OR UPDATE
x_planned_start OUT NOCOPY DATE,
x_planned_end OUT NOCOPY DATE,
x_scheduled_start OUT NOCOPY DATE,
x_scheduled_end OUT NOCOPY DATE,
x_actual_start OUT NOCOPY DATE,
x_actual_end OUT NOCOPY DATE,
x_date_selected OUT NOCOPY VARCHAR2,
x_show_on_calendar OUT NOCOPY VARCHAR2
)
IS
l_task_id NUMBER;
ELSIF p_operation = 'UPDATE'
THEN
l_task_id := get_task_id (p_sync_id => p_task_rec.syncid);
SELECT MAX (calendar_end_date)
FROM jtf_tasks_b
WHERE recurrence_rule_id = p_recurrence_rule_id;
SELECT DISTINCT exclusion_date ex_date
FROM jta_task_exclusions
WHERE recurrence_rule_id = p_recurrence_rule_id;
FUNCTION already_selected(p_task_id IN NUMBER
,p_sync_id IN NUMBER
,p_task_tbl IN jta_sync_task.task_tbl)
RETURN BOOLEAN
IS
l_selected BOOLEAN := FALSE;
l_selected := TRUE;
l_selected := TRUE;
RETURN l_selected;
END already_selected;
p_date_selected IN VARCHAR2,
p_timezone_id IN NUMBER,
p_syncanchor IN DATE,
p_planned_start_date IN DATE,
p_planned_end_date IN DATE,
p_scheduled_start_date IN DATE,
p_scheduled_end_date IN DATE,
p_actual_start_date IN DATE,
p_actual_end_date IN DATE,
p_calendar_start_date IN DATE,
p_calendar_end_date IN DATE,
p_alarm_on IN VARCHAR2,
p_alarm_start IN NUMBER,
p_recurrence_rule_id IN NUMBER,
p_occurs_uom IN VARCHAR2,
p_occurs_every IN NUMBER,
p_occurs_number IN NUMBER,
p_start_date_active IN DATE,
p_end_date_active IN DATE,
p_sunday IN VARCHAR2,
p_monday IN VARCHAR2,
p_tuesday IN VARCHAR2,
p_wednesday IN VARCHAR2,
p_thursday IN VARCHAR2,
p_friday IN VARCHAR2,
p_saturday IN VARCHAR2,
p_date_of_month IN VARCHAR2,
p_occurs_which IN VARCHAR2,
--p_get_data IN BOOLEAN,
x_task_rec IN OUT NOCOPY jta_sync_task.task_rec
)
IS
l_category_name VARCHAR2(240); -- Fix bug 2540722
IF p_operation <> G_DELETE
THEN
make_prefix (
p_assignment_status_id => get_assignment_status_id (p_task_id, p_resource_id),
p_source_object_type_code => x_task_rec.objectcode,
p_resource_type => p_owner_type_code,
p_resource_id => jta_sync_task.g_login_resource_id,
p_group_id => p_resource_id,
x_subject => x_task_rec.subject
);
x_task_rec.dateselected := NVL(p_date_selected,'S'); -- fix bug 2389092
PROCEDURE check_delete_data (
p_task_id IN NUMBER,
p_resource_id IN NUMBER,
p_objectcode IN VARCHAR2,
x_status_id OUT NOCOPY NUMBER,
x_delete_flag OUT NOCOPY VARCHAR2
)
IS
l_assignee_role VARCHAR2(30);
x_delete_flag := 'U'; -- UPDATE
x_delete_flag := 'X'; -- DO NOTHING
x_delete_flag := 'D'; -- DELETE
x_delete_flag := 'D';
END check_delete_data;
SELECT task_assignment_id
FROM jtf_task_all_assignments
WHERE task_id = p_task_id
AND resource_id = p_resource_id
AND resource_type_code = p_resource_type;
SELECT assignment_status_id
FROM jtf_task_all_assignments
WHERE task_id = p_task_id
AND resource_id = p_resource_id;
SELECT task_name, owner_id, owner_type_code
FROM jtf_tasks_vl
WHERE task_id = b_task_id;
SELECT a.assignee_role, a.assignment_status_id, r.resource_id
FROM jtf_rs_resource_extns r, jtf_task_all_assignments a
WHERE a.task_id = b_task_id
AND a.resource_id = b_resource_id
AND r.user_id = a.created_by;
SELECT DISTINCT fmu.menu_name
FROM fnd_menus fmu, fnd_objects fos, fnd_grants fgs
WHERE fmu.menu_id = fgs.menu_id -- grants joint to menus
AND fos.obj_name = 'JTF_TASK_RESOURCE'
AND fos.object_id = fgs.object_id -- grants joint to object
AND fgs.grantee_key = b_resource_id
AND fgs.grantee_type = 'USER'
AND fgs.start_date < SYSDATE
AND ( fgs.end_date >= SYSDATE
OR fgs.end_date IS NULL)
AND fgs.instance_pk2_value = 'RS_GROUP'
AND fgs.instance_pk1_value = b_group_id;
SELECT source_object_type_code
FROM jtf_tasks_b
WHERE task_id = b_task_id;
SELECT asg.assignee_role
, rs.resource_type_code
, rs.group_calendar_flag
, asg.assignment_status_id
, tsk.source_object_type_code
FROM (SELECT p_resource_id resource_id
, 'RS_EMPLOYEE' resource_type_code
, 'N' group_calendar_flag
FROM dual
UNION ALL
SELECT tm.team_id resource_id
, 'RS_TEAM' resource_type_code
, 'N' group_calendar_flag
FROM jtf_rs_team_members tm
WHERE tm.team_resource_id = p_resource_id
UNION ALL
SELECT gm.group_id resource_id
, 'RS_GROUP' resource_type_code
, 'N' group_calendar_flag
FROM jtf_rs_group_members gm
WHERE gm.resource_id = p_resource_id
UNION ALL
SELECT g.group_id resource_id
, 'RS_GROUP' resource_type_code
, 'Y' group_calendar_flag
FROM fnd_grants fg
, jtf_rs_groups_b g
WHERE fg.grantee_key = to_char(p_resource_id)
AND fg.grantee_type = 'USER'
AND fg.instance_pk2_value = 'RS_GROUP'
AND fg.instance_pk1_value = to_char(g.group_id)
) rs
, jtf_task_all_assignments asg
, jtf_tasks_b tsk
WHERE asg.resource_type_code = rs.resource_type_code
AND asg.resource_id = rs.resource_id
AND asg.task_id = tsk.task_id
AND tsk.task_id = p_task_id
ORDER BY rs.group_calendar_flag desc
,decode(rs.resource_type_code,
'RS_EMPLOYEE', 1,
'RS_GROUP', 2,
'RS_TEAM', 3);
FUNCTION get_update_type (p_task_id IN NUMBER,
p_resource_id IN NUMBER,
p_subject IN VARCHAR2)
RETURN VARCHAR2
IS
l_synced_resource_type VARCHAR2(30);
l_update_type VARCHAR2(15) := G_UPDATE_ALL; -- Added for fix bug 2442686
l_update_type := g_do_nothing; -- Added for fix bug 2442686
l_update_type := g_update_status;
l_update_type := g_do_nothing;
RETURN l_update_type; -- Added for fix bug 2442686
END get_update_type;
SELECT t.recurrence_rule_id
FROM jtf_tasks_b t
WHERE t.task_id = p_task_id;
IF NOT (l_invalid OR already_selected(p_task_id => rec_modify_nonrepeat.task_id, p_task_tbl => x_data))
THEN
IF p_get_data
THEN
add_task (
p_request_type => p_request_type,
p_resource_id => p_resource_id,
p_resource_type => p_resource_type,
p_recordindex => i+1,
p_operation => g_modify,
p_task_sync_id => rec_modify_nonrepeat.task_sync_id,
p_task_id => rec_modify_nonrepeat.task_id,
p_task_name => rec_modify_nonrepeat.task_name,
p_owner_type_code => rec_modify_nonrepeat.owner_type_code,
p_description => rec_modify_nonrepeat.description,
p_task_status_id => rec_modify_nonrepeat.task_status_id,
p_task_priority_id => rec_modify_nonrepeat.importance_level ,
p_private_flag => rec_modify_nonrepeat.private_flag,
p_date_selected => rec_modify_nonrepeat.date_selected,
p_timezone_id => rec_modify_nonrepeat.timezone_id,
p_syncanchor => rec_modify_nonrepeat.new_timestamp,
p_planned_start_date => rec_modify_nonrepeat.planned_start_date,
p_planned_end_date => rec_modify_nonrepeat.planned_end_date,
p_scheduled_start_date => rec_modify_nonrepeat.scheduled_start_date,
p_scheduled_end_date => rec_modify_nonrepeat.scheduled_end_date,
p_actual_start_date => rec_modify_nonrepeat.actual_start_date,
p_actual_end_date => rec_modify_nonrepeat.actual_end_date,
p_calendar_start_date => rec_modify_nonrepeat.calendar_start_date,
p_calendar_end_date => rec_modify_nonrepeat.calendar_end_date,
p_alarm_on => rec_modify_nonrepeat.alarm_on,
p_alarm_start => rec_modify_nonrepeat.alarm_start,
p_recurrence_rule_id => rec_modify_nonrepeat.recurrence_rule_id,
p_occurs_uom => NULL,
p_occurs_every => NULL,
p_occurs_number => NULL,
p_start_date_active => NULL,
p_end_date_active => NULL,
p_sunday => NULL,
p_monday => NULL,
p_tuesday => NULL,
p_wednesday => NULL,
p_thursday => NULL,
p_friday => NULL,
p_saturday => NULL,
p_date_of_month => NULL,
p_occurs_which => NULL,
x_task_rec => x_task_rec
);
ELSE -- For get_count, store the task_id selected so as to avoid the duplicate
i := i + 1;
IF NOT (l_invalid OR already_selected(p_task_id => rec_new_nonrepeat.task_id, p_task_tbl => x_data))
THEN
IF p_get_data
THEN
add_task (
p_request_type => p_request_type,
p_resource_id => p_resource_id,
p_resource_type => p_resource_type,
p_recordindex => i + 1,
p_operation => g_new,
p_task_sync_id => NULL,
p_task_id => rec_new_nonrepeat.task_id,
p_task_name => rec_new_nonrepeat.task_name,
p_owner_type_code => rec_new_nonrepeat.owner_type_code,
p_description => rec_new_nonrepeat.description,
p_task_status_id => rec_new_nonrepeat.task_status_id,
p_task_priority_id => rec_new_nonrepeat.importance_level ,
p_private_flag => rec_new_nonrepeat.private_flag,
p_date_selected => rec_new_nonrepeat.date_selected,
p_timezone_id => rec_new_nonrepeat.timezone_id,
p_syncanchor => rec_new_nonrepeat.new_timestamp,
p_planned_start_date => rec_new_nonrepeat.planned_start_date,
p_planned_end_date => rec_new_nonrepeat.planned_end_date,
p_scheduled_start_date => rec_new_nonrepeat.scheduled_start_date,
p_scheduled_end_date => rec_new_nonrepeat.scheduled_end_date,
p_actual_start_date => rec_new_nonrepeat.actual_start_date,
p_actual_end_date => rec_new_nonrepeat.actual_end_date,
p_calendar_start_date => rec_new_nonrepeat.calendar_start_date,
p_calendar_end_date => rec_new_nonrepeat.calendar_end_date,
p_alarm_on => rec_new_nonrepeat.alarm_on,
p_alarm_start => rec_new_nonrepeat.alarm_start,
p_recurrence_rule_id => rec_new_nonrepeat.recurrence_rule_id,
p_occurs_uom => NULL,
p_occurs_every => NULL,
p_occurs_number => NULL,
p_start_date_active => NULL,
p_end_date_active => NULL,
p_sunday => NULL,
p_monday => NULL,
p_tuesday => NULL,
p_wednesday => NULL,
p_thursday => NULL,
p_friday => NULL,
p_saturday => NULL,
p_date_of_month => NULL,
p_occurs_which => NULL,
--p_get_data => p_get_data,
x_task_rec => x_task_rec
);
ELSE -- For get_count, store the task_id selected so as to avoid the duplicate
i := i + 1;
PROCEDURE get_all_deleted_tasks (
p_request_type IN VARCHAR2,
p_syncanchor IN DATE,
p_recordindex IN NUMBER,
p_resource_id IN NUMBER,
p_resource_type IN VARCHAR2,
p_source_object_type IN VARCHAR2,
p_get_data IN BOOLEAN,
x_totaldeleted IN OUT NOCOPY NUMBER,
x_data IN OUT NOCOPY jta_sync_task.task_tbl
)
IS
i INTEGER := nvl(x_data.last,0);
FOR rec_delete IN jta_sync_task_cursors.c_delete_task (
p_syncanchor,
p_resource_id,
p_resource_type,
p_source_object_type
)
LOOP
IF NOT already_selected(p_sync_id => rec_delete.task_sync_id, p_task_tbl => x_data)
THEN
IF p_get_data
THEN
i := i + 1;
x_data(i).syncid := rec_delete.task_sync_id;
x_data(i).eventtype := g_delete;
jta_sync_task_map_pkg.delete_row (
p_task_sync_id => rec_delete.task_sync_id
);
ELSE -- For get_count, store the sync_id selected so as to avoid the duplicate
i := i + 1;
x_data (i).syncid := rec_delete.task_sync_id;
x_totaldeleted := x_totaldeleted + 1;
FOR rec_delete IN jta_sync_task_cursors.c_delete_assignee_reject (
p_syncanchor,
p_resource_id,
p_resource_type,
p_source_object_type
)
LOOP
IF NOT already_selected(p_sync_id => rec_delete.task_sync_id, p_task_tbl => x_data)
THEN
IF p_get_data
THEN
i := i + 1;
x_data(i).syncid := rec_delete.task_sync_id;
x_data(i).eventtype := g_delete;
jta_sync_task_map_pkg.delete_row (
p_task_sync_id => rec_delete.task_sync_id
);
ELSE -- For get_count, store the sync_id selected so as to avoid the duplicate
i := i + 1;
x_data (i).syncid := rec_delete.task_sync_id;
x_totaldeleted := x_totaldeleted + 1;
FOR rec_delete IN jta_sync_task_cursors.c_delete_assignment (
p_syncanchor,
p_resource_id,
p_resource_type,
p_source_object_type
)
LOOP
IF NOT already_selected(p_sync_id => rec_delete.task_sync_id, p_task_tbl => x_data)
THEN
IF p_get_data
THEN
i := i + 1;
x_data(i).eventtype := g_delete;
x_data(i).syncid := rec_delete.task_sync_id;
jta_sync_task_map_pkg.delete_row (
p_task_sync_id => rec_delete.task_sync_id
);
ELSE -- For get_count, store the sync_id selected so as to avoid the duplicate
i := i + 1;
x_data (i).syncid := rec_delete.task_sync_id;
x_totaldeleted := x_totaldeleted + 1;
FOR rec_delete IN jta_sync_task_cursors.c_delete_rejected_tasks (
p_syncanchor,
p_resource_id,
p_resource_type,
p_source_object_type
)
LOOP
IF NOT already_selected(p_sync_id => rec_delete.task_sync_id, p_task_tbl => x_data)
THEN
IF p_get_data
THEN
i := i + 1;
x_data (i).syncid := rec_delete.task_sync_id;
x_data (i).eventtype := g_delete;
jta_sync_task_map_pkg.delete_row (
p_task_sync_id => rec_delete.task_sync_id
);
ELSE -- For get_count, store the sync_id selected so as to avoid the duplicate
i := i + 1;
x_data (i).syncid := rec_delete.task_sync_id;
x_totaldeleted := x_totaldeleted + 1;
FOR rec_delete IN jta_sync_task_cursors.c_delete_unsubscribed(
p_resource_id,
p_resource_type,
p_source_object_type
)
LOOP
IF NOT already_selected(p_sync_id => rec_delete.task_sync_id, p_task_tbl => x_data)
THEN
IF p_get_data
THEN
i := i + 1;
x_data (i).syncid := rec_delete.task_sync_id;
x_data (i).eventtype := g_delete;
jta_sync_task_map_pkg.delete_row (
p_task_sync_id => rec_delete.task_sync_id
);
ELSE -- For get_count, store the sync_id selected so as to avoid the duplicate
i := i + 1;
x_data (i).syncid := rec_delete.task_sync_id;
x_totaldeleted := x_totaldeleted + 1;
END get_all_deleted_tasks;
IF NOT (l_invalid OR already_selected(p_task_id => rec_modify_repeat.task_id, p_task_tbl => x_data))
THEN
IF p_get_data
THEN
add_task (
p_request_type => p_request_type,
p_resource_id => p_resource_id,
p_resource_type => p_resource_type,
p_recordindex => i + 1,
p_operation => g_modify,
p_task_sync_id => rec_modify_repeat.task_sync_id,
p_task_id => rec_modify_repeat.task_id,
p_task_name => rec_modify_repeat.task_name,
p_owner_type_code => rec_modify_repeat.owner_type_code,
p_description => rec_modify_repeat.description,
p_task_status_id => rec_modify_repeat.task_status_id,
p_task_priority_id => null ,
p_private_flag => rec_modify_repeat.private_flag,
p_date_selected => rec_modify_repeat.date_selected,
p_timezone_id => rec_modify_repeat.timezone_id,
p_syncanchor => rec_modify_repeat.new_timestamp,
p_planned_start_date => rec_modify_repeat.planned_start_date,
p_planned_end_date => rec_modify_repeat.planned_end_date,
p_scheduled_start_date => rec_modify_repeat.scheduled_start_date,
p_scheduled_end_date => rec_modify_repeat.scheduled_end_date,
p_actual_start_date => rec_modify_repeat.actual_start_date,
p_actual_end_date => rec_modify_repeat.actual_end_date,
p_calendar_start_date => rec_modify_repeat.calendar_start_date,
p_calendar_end_date => rec_modify_repeat.calendar_end_date,
p_alarm_on => rec_modify_repeat.alarm_on,
p_alarm_start => rec_modify_repeat.alarm_start,
p_recurrence_rule_id => rec_modify_repeat.recurrence_rule_id,
p_occurs_uom => rec_modify_repeat.occurs_uom,
p_occurs_every => rec_modify_repeat.occurs_every,
p_occurs_number => rec_modify_repeat.occurs_number,
p_start_date_active => rec_modify_repeat.start_date_active,
p_end_date_active => rec_modify_repeat.end_date_active,
p_sunday => rec_modify_repeat.sunday,
p_monday => rec_modify_repeat.monday,
p_tuesday => rec_modify_repeat.tuesday,
p_wednesday => rec_modify_repeat.wednesday,
p_thursday => rec_modify_repeat.thursday,
p_friday => rec_modify_repeat.friday,
p_saturday => rec_modify_repeat.saturday,
p_date_of_month => rec_modify_repeat.date_of_month,
p_occurs_which => rec_modify_repeat.occurs_which,
x_task_rec => x_task_rec
--p_get_data => p_get_data
);
ELSE -- For get_count, store the sync_id selected so as to avoid the duplicate
i := i + 1;
IF NOT (l_invalid OR already_selected(p_task_id => rec_new_repeat.task_id, p_task_tbl => x_data))
THEN
IF p_get_data
THEN
add_task (
p_request_type => p_request_type,
p_resource_id => p_resource_id,
p_resource_type => p_resource_type,
p_recordindex => i + 1,
p_operation => g_new,
p_task_sync_id => null ,
p_task_id => rec_new_repeat.task_id,
p_task_name => rec_new_repeat.task_name,
p_owner_type_code => rec_new_repeat.owner_type_code,
p_description => rec_new_repeat.description,
p_task_status_id => rec_new_repeat.task_status_id,
p_task_priority_id => rec_new_repeat.importance_level,
p_private_flag => rec_new_repeat.private_flag,
p_date_selected => rec_new_repeat.date_selected,
p_timezone_id => rec_new_repeat.timezone_id,
p_syncanchor => rec_new_repeat.new_timestamp,
p_planned_start_date => rec_new_repeat.planned_start_date,
p_planned_end_date => rec_new_repeat.planned_end_date,
p_scheduled_start_date => rec_new_repeat.scheduled_start_date,
p_scheduled_end_date => rec_new_repeat.scheduled_end_date,
p_actual_start_date => rec_new_repeat.actual_start_date,
p_actual_end_date => rec_new_repeat.actual_end_date,
p_calendar_start_date => rec_new_repeat.calendar_start_date,
p_calendar_end_date => rec_new_repeat.calendar_end_date,
p_alarm_on => rec_new_repeat.alarm_on,
p_alarm_start => rec_new_repeat.alarm_start,
p_recurrence_rule_id => rec_new_repeat.recurrence_rule_id,
p_occurs_uom => rec_new_repeat.occurs_uom,
p_occurs_every => rec_new_repeat.occurs_every,
p_occurs_number => rec_new_repeat.occurs_number,
p_start_date_active => rec_new_repeat.start_date_active,
p_end_date_active => rec_new_repeat.end_date_active,
p_sunday => rec_new_repeat.sunday,
p_monday => rec_new_repeat.monday,
p_tuesday => rec_new_repeat.tuesday,
p_wednesday => rec_new_repeat.wednesday,
p_thursday => rec_new_repeat.thursday,
p_friday => rec_new_repeat.friday,
p_saturday => rec_new_repeat.saturday,
p_date_of_month => rec_new_repeat.date_of_month,
p_occurs_which => rec_new_repeat.occurs_which,
--p_get_data => p_get_data,
x_task_rec => x_task_rec
);
ELSE -- For get_count, store the sync_id selected so as to avoid the duplicate
i := i + 1;
l_date_selected VARCHAR2(100);
l_update_type VARCHAR2(15);
x_date_selected => l_date_selected,
x_show_on_calendar => l_show_on_calendar
);
p_date_selected => NULL, -- Fix Bug 2467021: For creation, pass NULL
p_alarm_start => l_alarm_mins,
p_alarm_start_uom => 'MIN',
p_alarm_interval_uom => 'MIN',
p_alarm_on => p_task_rec.alarmflag,
p_private_flag => p_task_rec.privateflag,
p_category_id => l_category_id,
x_return_status => l_return_status,
x_msg_count => l_msg_count,
x_msg_data => l_msg_data,
x_task_id => l_task_id
);
/*insert_or_update_mapping (
p_task_sync_id => p_task_rec.syncid,
p_task_id => l_task_id,
p_resource_id => p_resource_id,
p_mapping_type => p_mapping_type
);
PROCEDURE update_existing_data (
p_task_rec IN OUT NOCOPY jta_sync_task.task_rec,
p_exclusion_tbl IN jta_sync_task.exclusion_tbl,
p_resource_id IN NUMBER,
p_resource_type IN VARCHAR2
)
IS
l_ovn NUMBER;
l_date_selected VARCHAR2(100);
l_update_type VARCHAR2(15);
l_update_all VARCHAR2(5);
SELECT task_id,
planned_start_date,
planned_end_date,
scheduled_start_date,
scheduled_end_date,
actual_start_date,
actual_end_date,
calendar_start_date,
timezone_id
FROM jtf_tasks_b
WHERE recurrence_rule_id = b_recurrence_rule_id;
p_operation => 'UPDATE',
x_planned_start => l_planned_start_date,
x_planned_end => l_planned_end_date,
x_scheduled_start => l_scheduled_start_date,
x_scheduled_end => l_scheduled_end_date,
x_actual_start => l_actual_start_date,
x_actual_end => l_actual_end_date,
x_date_selected => l_date_selected,
x_show_on_calendar => l_show_on_calendar
);
l_update_type := get_update_type (
p_task_id => l_task_id,
p_resource_id => p_resource_id,
p_subject => p_task_rec.subject
);
IF l_update_type = g_update_all
THEN
IF p_exclusion_tbl.COUNT > 0
THEN
process_exclusions (
p_exclusion_tbl => p_exclusion_tbl,
p_rec_rule_id => l_rec_rule_id,
p_repeating_task_id => l_task_id,
p_task_rec => p_task_rec
);
l_update_type = jta_sync_task_common.g_update_all
THEN -- Changed Repeating Rule
IF p_task_rec.unit_of_measure = 'YER' THEN
l_occurs_month := to_number(to_char(p_task_rec.start_date, 'MM'));
jtf_task_recurrences_pvt.update_task_recurrence (
p_api_version => 1.0,
p_task_id => l_task_id,
p_recurrence_rule_id => l_rec_rule_id,
p_occurs_which => p_task_rec.occurs_which,
p_date_of_month => p_task_rec.date_of_month,
p_occurs_month => l_occurs_month,
p_occurs_uom => p_task_rec.unit_of_measure,
p_occurs_every => p_task_rec.occurs_every,
p_occurs_number => l_occurs_number,
p_start_date_active => p_task_rec.start_date,
p_end_date_active => p_task_rec.end_date,
p_sunday => p_task_rec.sunday,
p_monday => p_task_rec.monday,
p_tuesday => p_task_rec.tuesday,
p_wednesday => p_task_rec.wednesday,
p_thursday => p_task_rec.thursday,
p_friday => p_task_rec.friday,
p_saturday => p_task_rec.saturday,
x_new_recurrence_rule_id => l_new_recurrence_rule_id,
x_return_status => l_return_status,
x_msg_count => l_msg_count,
x_msg_data => l_msg_data
);
THEN-- Failed to update a task
jta_sync_common.put_messages_to_result (
p_task_rec,
p_status => 2,
p_user_message => 'JTA_SYNC_UPDATE_RECUR_FAIL'
);
END IF; -- l_update_type = g_update_all
IF l_update_type = g_update_all
THEN
-----------------------------------------------------------
-- Fix for the bug 2380399
-- : If the current sync has a change of any fields
-- along with the change of repeating rule,
-- The update_task_recurrence_rule API creates new repeating
-- tasks and updates the mapping record with the new first
-- task_id. Hence the new task_id must be picked from
-- mapping table again. And the new object_version_number
-- of the the new task_id must be selected for update of the
-- other fields
-----------------------------------------------------------
l_task_id := get_task_id (p_sync_id => p_task_rec.syncid);
jta_cal_appointment_pvt.update_appointment (
p_object_version_number => l_ovn ,
p_task_id => l_task_id,
p_task_name => NVL (l_task_name, ' '),
p_description => p_task_rec.description,
p_task_priority_id => p_task_rec.priorityid,
p_planned_start_date => l_planned_start_date,
p_planned_end_date => l_planned_end_date,
p_timezone_id => get_task_timezone_id (l_task_id),
p_private_flag => p_task_rec.privateflag,
p_alarm_start => l_alarm_mins,
p_alarm_on => p_task_rec.alarmflag,
p_category_id => l_category_id,
p_change_mode => 'A',
x_return_status => l_return_status
);
jtf_tasks_pvt.update_task (
p_api_version => 1.0,
p_init_msg_list => fnd_api.g_true,
p_commit => fnd_api.g_false,
p_task_id => l_task_id,
p_object_version_number => l_ovn,
p_task_name => NVL (l_task_name, ' '),
p_description => p_task_rec.description,
p_task_status_id => p_task_rec.statusid,
p_task_priority_id => p_task_rec.priorityid,
p_planned_start_date => l_planned_start_date,
p_planned_end_date => l_planned_end_date,
p_scheduled_start_date => l_scheduled_start_date,
p_scheduled_end_date => l_scheduled_end_date,
p_actual_start_date => l_actual_start_date,
p_actual_end_date => l_actual_end_date,
p_show_on_calendar => fnd_api.g_miss_char, -- Fix Bug 2467021: For update, pass g_miss_char
p_date_selected => fnd_api.g_miss_char, -- Fix Bug 2467021: For update, pass g_miss_char
p_alarm_start => l_alarm_mins,
p_alarm_start_uom => 'MIN',
p_timezone_id => get_task_timezone_id (l_task_id),
p_private_flag => p_task_rec.privateflag,
p_category_id => l_category_id,
p_change_mode => 'A',
p_enable_workflow => 'N',
p_abort_workflow => 'N',
x_return_status => l_return_status,
x_msg_count => l_msg_count,
x_msg_data => l_msg_data
);
THEN-- Failed to update a task
jta_sync_common.put_messages_to_result (
p_task_rec,
p_status => 2,
p_user_message => 'JTA_SYNC_UPDATE_TASK_FAIL'
); -- l_return_status
ELSIF l_update_type = g_update_status
THEN
l_task_assignment_id := get_assignment_id (
p_task_id => l_task_id,
p_resource_id => p_resource_id,
p_resource_type => p_resource_type
);
jtf_task_assignments_pvt.update_task_assignment (
p_api_version => 1.0,
p_object_version_number => l_ovn,
p_init_msg_list => fnd_api.g_true,
p_commit => fnd_api.g_false,
p_task_assignment_id => l_task_assignment_id,
p_assignment_status_id => 3, -- ACCEPT
--p_update_all => l_update_all,
--p_enable_workflow => 'N',
--p_abort_workflow => 'N',
x_return_status => l_return_status,
x_msg_count => l_msg_count,
x_msg_data => l_msg_data
);
p_user_message => 'JTA_SYNC_UPDATE_STS_FAIL'
);
END IF; -- l_update_type
END update_existing_data;
PROCEDURE delete_exclusion_task (
p_repeating_task_id IN NUMBER,
x_task_rec IN OUT NOCOPY jta_sync_task.task_rec
)
IS
l_ovn NUMBER;
jta_cal_appointment_pvt.delete_appointment (
p_object_version_number => l_ovn,
p_task_id => p_repeating_task_id,
p_delete_future_recurrences => fnd_api.g_false,
x_return_status => l_return_status
);
jtf_tasks_pvt.delete_task (
p_api_version => 1.0,
p_init_msg_list => fnd_api.g_true,
p_commit => fnd_api.g_false,
p_task_id => p_repeating_task_id,
p_object_version_number => l_ovn,
x_return_status => l_return_status,
p_delete_future_recurrences => fnd_api.g_false ,
x_msg_count => l_msg_count,
x_msg_data => l_msg_data
);
p_user_message => 'JTA_SYNC_DELETE_EXCLUSION_FAIL'
);
END delete_exclusion_task;
PROCEDURE delete_task_data (
p_task_rec IN OUT NOCOPY jta_sync_task.task_rec,
p_delete_map_flag IN BOOLEAN
)
IS
l_task_id NUMBER;
jta_cal_appointment_pvt.delete_appointment (
p_object_version_number => l_ovn,
p_task_id => l_task_id,
p_delete_future_recurrences => 'A',
x_return_status => l_return_status
);
jtf_tasks_pvt.delete_task (
p_api_version => 1.0,
p_init_msg_list => fnd_api.g_true,
p_commit => fnd_api.g_false,
p_task_id => l_task_id,
p_object_version_number => l_ovn,
p_delete_future_recurrences => 'A',
x_return_status => l_return_status,
x_msg_count => l_msg_count,
x_msg_data => l_msg_data
);
IF p_delete_map_flag
THEN
jta_sync_task_map_pkg.delete_row (
p_task_sync_id => p_task_rec.syncid
);
p_user_message => 'JTA_SYNC_DELETE_TASK_FAILED'
);
END delete_task_data;
l_deleted BOOLEAN := FALSE;
l_update_all varchar2(1) ;
l_update_all := 'Y' ;
l_update_all := null ;
jtf_task_assignments_pvt.update_task_assignment (
p_api_version => 1.0,
p_object_version_number => l_ovn,
p_init_msg_list => fnd_api.g_true,
p_commit => fnd_api.g_false,
p_task_assignment_id => l_task_assignment_id,
p_assignment_status_id => 4, -- reject
x_return_status => l_return_status,
x_msg_count => l_msg_count,
x_msg_data => l_msg_data
--p_enable_workflow => 'N',
--p_abort_workflow => 'N'
);
jta_sync_task_map_pkg.delete_row(p_task_sync_id => p_task_rec.syncid);
p_user_message => 'JTA_SYNC_UPDATE_STS_FAIL'
);
SELECT jtrr.*
FROM jtf_task_recur_rules jtrr, jtf_tasks_b jtb
WHERE jtb.task_id = b_task_id
AND jtb.recurrence_rule_id IS NOT NULL
AND jtrr.recurrence_rule_id = jtb.recurrence_rule_id;
SELECT closed_flag, completed_flag, cancelled_flag, rejected_flag,
assigned_flag, working_flag, schedulable_flag, accepted_flag,
on_hold_flag, approved_flag
FROM jtf_task_statuses_b
WHERE task_status_id = p_task_status_id;
x_operation := jta_sync_task_common.g_delete;
x_operation := jta_sync_task_common.g_delete;
x_operation := jta_sync_task_common.g_delete;
SELECT 1 INTO l_num
FROM
fnd_user
,fnd_user_resp_groups
,jtf_state_rules_b
, jtf_state_responsibilities
WHERE fnd_user.user_id = fnd_global.user_id
AND fnd_user.user_id = fnd_user_resp_groups.user_id
AND fnd_user_resp_groups.responsibility_id = jtf_state_responsibilities.responsibility_id
AND jtf_state_responsibilities.rule_id = jtf_state_rules_b.rule_id;
SELECT 1
FROM jta_sync_task_mapping
WHERE task_sync_id = b_syncid;