[Home] [Help]
PACKAGE BODY: APPS.OKS_CTZ_PVT
Source
1 PACKAGE BODY OKS_CTZ_PVT AS
2 /* $Header: OKSCOVZB.pls 120.1 2005/07/15 09:22:43 parkumar noship $ */
3 ---------------------------------------------------------------------------
4 -- PROCEDURE load_error_tbl
5 ---------------------------------------------------------------------------
6 PROCEDURE load_error_tbl (
7 px_error_rec IN OUT NOCOPY OKC_API.ERROR_REC_TYPE,
8 px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
9
10 j INTEGER := NVL(px_error_tbl.LAST, 0) + 1;
11 last_msg_idx INTEGER := FND_MSG_PUB.COUNT_MSG;
12 l_msg_idx INTEGER := FND_MSG_PUB.G_NEXT;
13 BEGIN
14 -- FND_MSG_PUB has a small error in it. If we call FND_MSG_PUB.COUNT_AND_GET before
15 -- we call FND_MSG_PUB.GET, the variable FND_MSG_PUB uses to control the index of the
16 -- message stack gets set to 1. This makes sense until we call FND_MSG_PUB.GET which
17 -- automatically increments the index by 1, (making it 2), however, when the GET function
18 -- attempts to pull message 2, we get a NO_DATA_FOUND exception because there isn't any
19 -- message 2. To circumvent this problem, check the amount of messages and compensate.
20 -- Again, this error only occurs when 1 message is on the stack because COUNT_AND_GET
21 -- will only update the index variable when 1 and only 1 message is on the stack.
22 IF (last_msg_idx = 1) THEN
23 l_msg_idx := FND_MSG_PUB.G_FIRST;
24 END IF;
25 LOOP
26 fnd_msg_pub.get(
27 p_msg_index => l_msg_idx,
28 p_encoded => fnd_api.g_false,
29 p_data => px_error_rec.msg_data,
30 p_msg_index_out => px_error_rec.msg_count);
31 px_error_tbl(j) := px_error_rec;
32 j := j + 1;
33 EXIT WHEN (px_error_rec.msg_count = last_msg_idx);
34 END LOOP;
35 END load_error_tbl;
36 ---------------------------------------------------------------------------
37 -- FUNCTION find_highest_exception
38 ---------------------------------------------------------------------------
39 -- Finds the highest exception (G_RET_STS_UNEXP_ERROR)
40 -- in a OKC_API.ERROR_TBL_TYPE, and returns it.
41 FUNCTION find_highest_exception(
42 p_error_tbl IN OKC_API.ERROR_TBL_TYPE
43 ) RETURN VARCHAR2 IS
44 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
45 i INTEGER := 1;
46 BEGIN
47 IF (p_error_tbl.COUNT > 0) THEN
48 i := p_error_tbl.FIRST;
49 LOOP
50 IF (p_error_tbl(i).error_type <> OKC_API.G_RET_STS_SUCCESS) THEN
51 IF (l_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
52 l_return_status := p_error_tbl(i).error_type;
53 END IF;
54 END IF;
55 EXIT WHEN (i = p_error_tbl.LAST);
56 i := p_error_tbl.NEXT(i);
57 END LOOP;
58 END IF;
59 RETURN(l_return_status);
60 END find_highest_exception;
61 ---------------------------------------------------------------------------
62 -- FUNCTION get_seq_id
63 ---------------------------------------------------------------------------
64 FUNCTION get_seq_id RETURN NUMBER IS
65 BEGIN
66 RETURN(okc_p_util.raw_to_number(sys_guid()));
67 END get_seq_id;
68
69 ---------------------------------------------------------------------------
70 -- PROCEDURE qc
71 ---------------------------------------------------------------------------
72 PROCEDURE qc IS
73 BEGIN
74 null;
75 END qc;
76
77 ---------------------------------------------------------------------------
78 -- PROCEDURE change_version
79 ---------------------------------------------------------------------------
80 PROCEDURE change_version IS
81 BEGIN
82 null;
83 END change_version;
84
85 ---------------------------------------------------------------------------
86 -- PROCEDURE api_copy
87 ---------------------------------------------------------------------------
88 PROCEDURE api_copy IS
89 BEGIN
90 null;
91 END api_copy;
92
93 ---------------------------------------------------------------------------
94 -- FUNCTION get_rec for: OKS_COVERAGE_TIMEZONES_V
95 ---------------------------------------------------------------------------
96 FUNCTION get_rec (
97 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
98 x_no_data_found OUT NOCOPY BOOLEAN
99 ) RETURN OksCoverageTimezonesVRecType IS
100 CURSOR oks_ctzv_pk_csr (p_id IN NUMBER) IS
101 SELECT
102 ID,
103 CLE_ID,
104 DEFAULT_YN,
105 TIMEZONE_ID,
106 DNZ_CHR_ID,
107 SECURITY_GROUP_ID,
108 PROGRAM_APPLICATION_ID,
109 PROGRAM_ID,
110 PROGRAM_UPDATE_DATE,
111 REQUEST_ID,
112 CREATED_BY,
113 CREATION_DATE,
114 LAST_UPDATED_BY,
115 LAST_UPDATE_DATE,
116 LAST_UPDATE_LOGIN,
117 OBJECT_VERSION_NUMBER,
118 -- R12 Data Model Changes 4485150 Start
119 ORIG_SYSTEM_ID1,
120 ORIG_SYSTEM_REFERENCE1,
121 ORIG_SYSTEM_SOURCE_CODE
122 -- R12 Data Model Changes 4485150 End
123 FROM Oks_Coverage_Timezones_V
124 WHERE oks_coverage_timezones_v.id = p_id;
125 l_oks_ctzv_pk oks_ctzv_pk_csr%ROWTYPE;
126 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType;
127 BEGIN
128 x_no_data_found := TRUE;
129 -- Get current database values
130 OPEN oks_ctzv_pk_csr (p_oks_coverage_timezones_v_rec.id);
131 FETCH oks_ctzv_pk_csr INTO
132 l_oks_coverage_timezones_v_rec.id,
133 l_oks_coverage_timezones_v_rec.cle_id,
134 l_oks_coverage_timezones_v_rec.default_yn,
135 l_oks_coverage_timezones_v_rec.timezone_id,
136 l_oks_coverage_timezones_v_rec.dnz_chr_id,
137 l_oks_coverage_timezones_v_rec.security_group_id,
138 l_oks_coverage_timezones_v_rec.program_application_id,
139 l_oks_coverage_timezones_v_rec.program_id,
140 l_oks_coverage_timezones_v_rec.program_update_date,
141 l_oks_coverage_timezones_v_rec.request_id,
142 l_oks_coverage_timezones_v_rec.created_by,
143 l_oks_coverage_timezones_v_rec.creation_date,
144 l_oks_coverage_timezones_v_rec.last_updated_by,
145 l_oks_coverage_timezones_v_rec.last_update_date,
146 l_oks_coverage_timezones_v_rec.last_update_login,
147 l_oks_coverage_timezones_v_rec.object_version_number,
148 -- R12 Data Model Changes 4485150 Start
149 l_oks_coverage_timezones_v_rec.orig_system_id1,
150 l_oks_coverage_timezones_v_rec.orig_system_reference1,
151 l_oks_coverage_timezones_v_rec.orig_system_source_code
152 -- R12 Data Model Changes 4485150 End
153 ;
154 x_no_data_found := oks_ctzv_pk_csr%NOTFOUND;
155 CLOSE oks_ctzv_pk_csr;
156 RETURN(l_oks_coverage_timezones_v_rec);
157 END get_rec;
158
159 ------------------------------------------------------------------
160 -- This version of get_rec sets error messages if no data found --
161 ------------------------------------------------------------------
162 FUNCTION get_rec (
163 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
164 x_return_status OUT NOCOPY VARCHAR2
165 ) RETURN OksCoverageTimezonesVRecType IS
166 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType;
167 l_row_notfound BOOLEAN := TRUE;
168 BEGIN
169 x_return_status := OKC_API.G_RET_STS_SUCCESS;
170 l_oks_coverage_timezones_v_rec := get_rec(p_oks_coverage_timezones_v_rec, l_row_notfound);
171 IF (l_row_notfound) THEN
172 OKC_API.set_message(G_APP_NAME,G_INVALID_VALUE,G_COL_NAME_TOKEN,'ID');
173 x_return_status := OKC_API.G_RET_STS_ERROR;
174 END IF;
175 RETURN(l_oks_coverage_timezones_v_rec);
176 END get_rec;
177 -----------------------------------------------------------
178 -- So we don't have to pass an "l_row_notfound" variable --
179 -----------------------------------------------------------
180 FUNCTION get_rec (
181 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType
182 ) RETURN OksCoverageTimezonesVRecType IS
183 l_row_not_found BOOLEAN := TRUE;
184 BEGIN
185 RETURN(get_rec(p_oks_coverage_timezones_v_rec, l_row_not_found));
186 END get_rec;
187 ---------------------------------------------------------------------------
188 -- FUNCTION get_rec for: OKS_COVERAGE_TIMEZONES
189 ---------------------------------------------------------------------------
190 FUNCTION get_rec (
191 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType,
192 x_no_data_found OUT NOCOPY BOOLEAN
193 ) RETURN OksCoverageTimezonesRecType IS
194 CURSOR oks_ctz_pk_csr (p_id IN NUMBER) IS
195 SELECT
196 ID,
197 CLE_ID,
198 DEFAULT_YN,
199 TIMEZONE_ID,
200 DNZ_CHR_ID,
201 PROGRAM_APPLICATION_ID,
202 PROGRAM_ID,
203 PROGRAM_UPDATE_DATE,
204 REQUEST_ID,
205 CREATED_BY,
206 CREATION_DATE,
207 LAST_UPDATED_BY,
208 LAST_UPDATE_DATE,
209 LAST_UPDATE_LOGIN,
210 OBJECT_VERSION_NUMBER,
211 -- R12 Data Model Changes 4485150 Start
212 ORIG_SYSTEM_ID1,
213 ORIG_SYSTEM_REFERENCE1,
214 ORIG_SYSTEM_SOURCE_CODE
215 -- R12 Data Model Changes 4485150 End
216 FROM Oks_Coverage_Timezones
217 WHERE oks_coverage_timezones.id = p_id;
218 l_oks_ctz_pk oks_ctz_pk_csr%ROWTYPE;
219 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
220 BEGIN
221 x_no_data_found := TRUE;
222 -- Get current database values
223 OPEN oks_ctz_pk_csr (p_oks_coverage_timezones_rec.id);
224 FETCH oks_ctz_pk_csr INTO
225 l_oks_coverage_timezones_rec.id,
226 l_oks_coverage_timezones_rec.cle_id,
227 l_oks_coverage_timezones_rec.default_yn,
228 l_oks_coverage_timezones_rec.timezone_id,
229 l_oks_coverage_timezones_rec.dnz_chr_id,
230 l_oks_coverage_timezones_rec.program_application_id,
231 l_oks_coverage_timezones_rec.program_id,
232 l_oks_coverage_timezones_rec.program_update_date,
233 l_oks_coverage_timezones_rec.request_id,
234 l_oks_coverage_timezones_rec.created_by,
235 l_oks_coverage_timezones_rec.creation_date,
236 l_oks_coverage_timezones_rec.last_updated_by,
237 l_oks_coverage_timezones_rec.last_update_date,
238 l_oks_coverage_timezones_rec.last_update_login,
239 l_oks_coverage_timezones_rec.object_version_number,
240 -- R12 Data Model Changes 4485150 Start
241 l_oks_coverage_timezones_rec.orig_system_id1,
242 l_oks_coverage_timezones_rec.orig_system_reference1,
243 l_oks_coverage_timezones_rec.orig_system_source_code
244 -- R12 Data Model Changes 4485150 End
245
246 ;
247 x_no_data_found := oks_ctz_pk_csr%NOTFOUND;
248 CLOSE oks_ctz_pk_csr;
249 RETURN(l_oks_coverage_timezones_rec);
250 END get_rec;
251
252 ------------------------------------------------------------------
253 -- This version of get_rec sets error messages if no data found --
254 ------------------------------------------------------------------
255 FUNCTION get_rec (
256 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType,
257 x_return_status OUT NOCOPY VARCHAR2
258 ) RETURN OksCoverageTimezonesRecType IS
259 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
260 l_row_notfound BOOLEAN := TRUE;
261 BEGIN
262 x_return_status := OKC_API.G_RET_STS_SUCCESS;
263 l_oks_coverage_timezones_rec := get_rec(p_oks_coverage_timezones_rec, l_row_notfound);
264 IF (l_row_notfound) THEN
265 OKC_API.set_message(G_APP_NAME,G_INVALID_VALUE,G_COL_NAME_TOKEN,'ID');
266 x_return_status := OKC_API.G_RET_STS_ERROR;
267 END IF;
268 RETURN(l_oks_coverage_timezones_rec);
269 END get_rec;
270 -----------------------------------------------------------
271 -- So we don't have to pass an "l_row_notfound" variable --
272 -----------------------------------------------------------
273 FUNCTION get_rec (
274 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType
275 ) RETURN OksCoverageTimezonesRecType IS
276 l_row_not_found BOOLEAN := TRUE;
277 BEGIN
278 RETURN(get_rec(p_oks_coverage_timezones_rec, l_row_not_found));
279 END get_rec;
280 ---------------------------------------------------------------------------
281 -- FUNCTION null_out_defaults for: OKS_COVERAGE_TIMEZONES_V
282 ---------------------------------------------------------------------------
283 FUNCTION null_out_defaults (
284 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType
285 ) RETURN OksCoverageTimezonesVRecType IS
286 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType := p_oks_coverage_timezones_v_rec;
287 BEGIN
288 IF (l_oks_coverage_timezones_v_rec.id = OKC_API.G_MISS_NUM ) THEN
289 l_oks_coverage_timezones_v_rec.id := NULL;
290 END IF;
291 IF (l_oks_coverage_timezones_v_rec.cle_id = OKC_API.G_MISS_NUM ) THEN
292 l_oks_coverage_timezones_v_rec.cle_id := NULL;
293 END IF;
294 IF (l_oks_coverage_timezones_v_rec.default_yn = OKC_API.G_MISS_CHAR ) THEN
295 l_oks_coverage_timezones_v_rec.default_yn := NULL;
296 END IF;
297 IF (l_oks_coverage_timezones_v_rec.timezone_id = OKC_API.G_MISS_NUM ) THEN
298 l_oks_coverage_timezones_v_rec.timezone_id := NULL;
299 END IF;
300 IF (l_oks_coverage_timezones_v_rec.dnz_chr_id = OKC_API.G_MISS_NUM ) THEN
301 l_oks_coverage_timezones_v_rec.dnz_chr_id := NULL;
302 END IF;
303 IF (l_oks_coverage_timezones_v_rec.security_group_id = OKC_API.G_MISS_NUM ) THEN
304 l_oks_coverage_timezones_v_rec.security_group_id := NULL;
305 END IF;
306 IF (l_oks_coverage_timezones_v_rec.program_application_id = OKC_API.G_MISS_NUM ) THEN
307 l_oks_coverage_timezones_v_rec.program_application_id := NULL;
308 END IF;
309 IF (l_oks_coverage_timezones_v_rec.program_id = OKC_API.G_MISS_NUM ) THEN
310 l_oks_coverage_timezones_v_rec.program_id := NULL;
311 END IF;
312 IF (l_oks_coverage_timezones_v_rec.program_update_date = OKC_API.G_MISS_DATE ) THEN
313 l_oks_coverage_timezones_v_rec.program_update_date := NULL;
314 END IF;
315 IF (l_oks_coverage_timezones_v_rec.request_id = OKC_API.G_MISS_NUM ) THEN
316 l_oks_coverage_timezones_v_rec.request_id := NULL;
317 END IF;
318 IF (l_oks_coverage_timezones_v_rec.created_by = OKC_API.G_MISS_NUM ) THEN
319 l_oks_coverage_timezones_v_rec.created_by := NULL;
320 END IF;
321 IF (l_oks_coverage_timezones_v_rec.creation_date = OKC_API.G_MISS_DATE ) THEN
322 l_oks_coverage_timezones_v_rec.creation_date := NULL;
323 END IF;
324 IF (l_oks_coverage_timezones_v_rec.last_updated_by = OKC_API.G_MISS_NUM ) THEN
325 l_oks_coverage_timezones_v_rec.last_updated_by := NULL;
326 END IF;
327 IF (l_oks_coverage_timezones_v_rec.last_update_date = OKC_API.G_MISS_DATE ) THEN
328 l_oks_coverage_timezones_v_rec.last_update_date := NULL;
329 END IF;
330 IF (l_oks_coverage_timezones_v_rec.last_update_login = OKC_API.G_MISS_NUM ) THEN
331 l_oks_coverage_timezones_v_rec.last_update_login := NULL;
332 END IF;
333 IF (l_oks_coverage_timezones_v_rec.object_version_number = OKC_API.G_MISS_NUM ) THEN
334 l_oks_coverage_timezones_v_rec.object_version_number := NULL;
335 END IF;
336 -- R12 Data Model Changes 4485150 Start
337 IF (l_oks_coverage_timezones_v_rec.orig_system_id1 = OKC_API.G_MISS_NUM ) THEN
338 l_oks_coverage_timezones_v_rec.orig_system_id1 := NULL;
339 END IF;
340 IF (l_oks_coverage_timezones_v_rec.orig_system_reference1 = OKC_API.G_MISS_CHAR ) THEN
341 l_oks_coverage_timezones_v_rec.orig_system_reference1 := NULL;
342 END IF;
343 IF (l_oks_coverage_timezones_v_rec.orig_system_source_code = OKC_API.G_MISS_CHAR ) THEN
344 l_oks_coverage_timezones_v_rec.orig_system_source_code := NULL;
345 END IF;
346 -- R12 Data Model Changes 4485150 End
347 RETURN(l_oks_coverage_timezones_v_rec);
348 END null_out_defaults;
349 ---------------------------------
350 -- Validate_Attributes for: ID --
351 ---------------------------------
352 PROCEDURE validate_id(
353 x_return_status OUT NOCOPY VARCHAR2,
354 p_id IN NUMBER) IS
355 BEGIN
356 x_return_status := OKC_API.G_RET_STS_SUCCESS;
357 IF (p_id = OKC_API.G_MISS_NUM OR
358 p_id IS NULL)
359 THEN
360 OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE, G_COL_NAME_TOKEN, 'id');
361 x_return_status := OKC_API.G_RET_STS_ERROR;
362 RAISE G_EXCEPTION_HALT_VALIDATION;
363 END IF;
364 EXCEPTION
365 WHEN G_EXCEPTION_HALT_VALIDATION THEN
366 null;
367 WHEN OTHERS THEN
368 OKC_API.SET_MESSAGE( p_app_name => G_APP_NAME
369 ,p_msg_name => G_UNEXPECTED_ERROR
370 ,p_token1 => G_SQLCODE_TOKEN
371 ,p_token1_value => SQLCODE
372 ,p_token2 => G_SQLERRM_TOKEN
373 ,p_token2_value => SQLERRM);
374 x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
375 END validate_id;
376 ----------------------------------------------------
377 -- Validate_Attributes for: OBJECT_VERSION_NUMBER --
378 ----------------------------------------------------
379 PROCEDURE validate_object_version_number(
380 x_return_status OUT NOCOPY VARCHAR2,
381 p_object_version_number IN NUMBER) IS
382 BEGIN
383 x_return_status := OKC_API.G_RET_STS_SUCCESS;
384 IF (p_object_version_number = OKC_API.G_MISS_NUM OR
385 p_object_version_number IS NULL)
386 THEN
387 OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE, G_COL_NAME_TOKEN, 'object_version_number');
388 x_return_status := OKC_API.G_RET_STS_ERROR;
389 RAISE G_EXCEPTION_HALT_VALIDATION;
390 END IF;
391 EXCEPTION
392 WHEN G_EXCEPTION_HALT_VALIDATION THEN
393 null;
394 WHEN OTHERS THEN
395 OKC_API.SET_MESSAGE( p_app_name => G_APP_NAME
396 ,p_msg_name => G_UNEXPECTED_ERROR
397 ,p_token1 => G_SQLCODE_TOKEN
398 ,p_token1_value => SQLCODE
399 ,p_token2 => G_SQLERRM_TOKEN
400 ,p_token2_value => SQLERRM);
401 x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
402 END validate_object_version_number;
403 ---------------------------------------------------------------------------
404 -- FUNCTION Validate_Attributes
405 ---------------------------------------------------------------------------
406 ------------------------------------------------------
407 -- Validate_Attributes for:OKS_COVERAGE_TIMEZONES_V --
408 ------------------------------------------------------
409 FUNCTION Validate_Attributes (
410 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType
411 ) RETURN VARCHAR2 IS
412 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
413 x_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
414 BEGIN
415 -----------------------------
416 -- Column Level Validation --
417 -----------------------------
418 -- ***
419 -- id
420 -- ***
421 validate_id(x_return_status, p_oks_coverage_timezones_v_rec.id);
422 IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
423 l_return_status := x_return_status;
424 RAISE G_EXCEPTION_HALT_VALIDATION;
425 END IF;
426
427 -- ***
428 -- object_version_number
429 -- ***
430 validate_object_version_number(x_return_status, p_oks_coverage_timezones_v_rec.object_version_number);
431 IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
432 l_return_status := x_return_status;
433 RAISE G_EXCEPTION_HALT_VALIDATION;
434 END IF;
435
436 RETURN(l_return_status);
437 EXCEPTION
438 WHEN G_EXCEPTION_HALT_VALIDATION THEN
439 RETURN(l_return_status);
440 WHEN OTHERS THEN
441 OKC_API.SET_MESSAGE( p_app_name => G_APP_NAME
442 ,p_msg_name => G_UNEXPECTED_ERROR
443 ,p_token1 => G_SQLCODE_TOKEN
444 ,p_token1_value => SQLCODE
445 ,p_token2 => G_SQLERRM_TOKEN
446 ,p_token2_value => SQLERRM);
447 l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
448 RETURN(l_return_status);
449 END Validate_Attributes;
450 ---------------------------------------------------------------------------
451 -- PROCEDURE Validate_Record
452 ---------------------------------------------------------------------------
453 --------------------------------------------------
454 -- Validate Record for:OKS_COVERAGE_TIMEZONES_V --
455 --------------------------------------------------
456 FUNCTION Validate_Record (
457 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
458 p_db_oks_coverage_tim44 IN OksCoverageTimezonesVRecType
459 ) RETURN VARCHAR2 IS
460 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
461 BEGIN
462 RETURN (l_return_status);
463 END Validate_Record;
464 FUNCTION Validate_Record (
465 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType
466 ) RETURN VARCHAR2 IS
467 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
468 l_db_oks_coverage_tim44 OksCoverageTimezonesVRecType := get_rec(p_oks_coverage_timezones_v_rec);
469 BEGIN
470 l_return_status := Validate_Record(p_oks_coverage_timezones_v_rec => p_oks_coverage_timezones_v_rec,
471 p_db_oks_coverage_tim44 => l_db_oks_coverage_tim44);
472 RETURN (l_return_status);
473 END Validate_Record;
474
475 ---------------------------------------------------------------------------
476 -- PROCEDURE Migrate
477 ---------------------------------------------------------------------------
478 PROCEDURE migrate (
479 p_from IN OksCoverageTimezonesVRecType,
480 p_to IN OUT NOCOPY OksCoverageTimezonesRecType
481 ) IS
482 BEGIN
483 p_to.id := p_from.id;
484 p_to.cle_id := p_from.cle_id;
485 p_to.default_yn := p_from.default_yn;
486 p_to.timezone_id := p_from.timezone_id;
487 p_to.dnz_chr_id := p_from.dnz_chr_id;
488 p_to.program_application_id := p_from.program_application_id;
489 p_to.program_id := p_from.program_id;
490 p_to.program_update_date := p_from.program_update_date;
491 p_to.request_id := p_from.request_id;
492 p_to.created_by := p_from.created_by;
493 p_to.creation_date := p_from.creation_date;
494 p_to.last_updated_by := p_from.last_updated_by;
495 p_to.last_update_date := p_from.last_update_date;
496 p_to.last_update_login := p_from.last_update_login;
497 p_to.object_version_number := p_from.object_version_number;
498 -- R12 Data Model Changes 4485150 Start
499 p_to.orig_system_id1 := p_from.orig_system_id1;
500 p_to.orig_system_reference1 := p_from.orig_system_reference1;
501 p_to.orig_system_source_code := p_from.orig_system_source_code;
502 -- R12 Data Model Changes 4485150 End
503 END migrate;
504 PROCEDURE migrate (
505 p_from IN OksCoverageTimezonesRecType,
506 p_to IN OUT NOCOPY OksCoverageTimezonesVRecType
507 ) IS
508 BEGIN
509 p_to.id := p_from.id;
510 p_to.cle_id := p_from.cle_id;
511 p_to.default_yn := p_from.default_yn;
512 p_to.timezone_id := p_from.timezone_id;
513 p_to.dnz_chr_id := p_from.dnz_chr_id;
514 p_to.program_application_id := p_from.program_application_id;
515 p_to.program_id := p_from.program_id;
516 p_to.program_update_date := p_from.program_update_date;
517 p_to.request_id := p_from.request_id;
518 p_to.created_by := p_from.created_by;
519 p_to.creation_date := p_from.creation_date;
520 p_to.last_updated_by := p_from.last_updated_by;
521 p_to.last_update_date := p_from.last_update_date;
522 p_to.last_update_login := p_from.last_update_login;
523 p_to.object_version_number := p_from.object_version_number;
524 -- R12 Data Model Changes 4485150 Start
525 p_to.orig_system_id1 := p_from.orig_system_id1;
526 p_to.orig_system_reference1 := p_from.orig_system_reference1;
527 p_to.orig_system_source_code := p_from.orig_system_source_code;
528 -- R12 Data Model Changes 4485150 End
529 END migrate;
530 ---------------------------------------------------------------------------
531 -- PROCEDURE validate_row
532 ---------------------------------------------------------------------------
533 -----------------------------------------------
534 -- validate_row for:OKS_COVERAGE_TIMEZONES_V --
535 -----------------------------------------------
536 PROCEDURE validate_row(
537 p_api_version IN NUMBER,
538 p_init_msg_list IN VARCHAR2,
539 x_return_status OUT NOCOPY VARCHAR2,
540 x_msg_count OUT NOCOPY NUMBER,
541 x_msg_data OUT NOCOPY VARCHAR2,
542 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType) IS
543
544 l_api_version CONSTANT NUMBER := 1;
545 l_api_name CONSTANT VARCHAR2(30) := 'V_validate_row';
546 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
547 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType := p_oks_coverage_timezones_v_rec;
548 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
549 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
550 BEGIN
551 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
552 G_PKG_NAME,
553 p_init_msg_list,
554 l_api_version,
555 p_api_version,
556 '_PVT',
557 x_return_status);
558 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
559 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
560 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
561 RAISE OKC_API.G_EXCEPTION_ERROR;
562 END IF;
563 --- Validate all non-missing attributes (Item Level Validation)
564 l_return_status := Validate_Attributes(l_oks_coverage_timezones_v_rec);
565 --- If any errors happen abort API
566 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
567 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
568 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
569 RAISE OKC_API.G_EXCEPTION_ERROR;
570 END IF;
571 l_return_status := Validate_Record(l_oks_coverage_timezones_v_rec);
572 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
573 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
574 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
575 RAISE OKC_API.G_EXCEPTION_ERROR;
576 END IF;
577 x_return_status := l_return_status;
578 EXCEPTION
579 WHEN OKC_API.G_EXCEPTION_ERROR THEN
580 x_return_status := OKC_API.HANDLE_EXCEPTIONS
581 (
582 l_api_name,
583 G_PKG_NAME,
584 'OKC_API.G_RET_STS_ERROR',
585 x_msg_count,
586 x_msg_data,
587 '_PVT'
588 );
589 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
590 x_return_status := OKC_API.HANDLE_EXCEPTIONS
591 (
592 l_api_name,
593 G_PKG_NAME,
594 'OKC_API.G_RET_STS_UNEXP_ERROR',
595 x_msg_count,
596 x_msg_data,
597 '_PVT'
598 );
599 WHEN OTHERS THEN
600 x_return_status := OKC_API.HANDLE_EXCEPTIONS
601 (
602 l_api_name,
603 G_PKG_NAME,
604 'OTHERS',
605 x_msg_count,
606 x_msg_data,
607 '_PVT'
608 );
609 END validate_row;
610 ----------------------------------------------------------
611 -- PL/SQL TBL validate_row for:OKS_COVERAGE_TIMEZONES_V --
612 ----------------------------------------------------------
613 PROCEDURE validate_row(
614 p_api_version IN NUMBER,
615 p_init_msg_list IN VARCHAR2,
616 x_return_status OUT NOCOPY VARCHAR2,
617 x_msg_count OUT NOCOPY NUMBER,
618 x_msg_data OUT NOCOPY VARCHAR2,
619 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType,
620 px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
621
622 l_api_version CONSTANT NUMBER := 1;
623 l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_validate_row';
624 i NUMBER := 0;
625 BEGIN
626 OKC_API.init_msg_list(p_init_msg_list);
627 -- Make sure PL/SQL table has records in it before passing
628 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
629 i := p_oks_coverage_timezones_v_tbl.FIRST;
630 LOOP
631 DECLARE
632 l_error_rec OKC_API.ERROR_REC_TYPE;
633 BEGIN
634 l_error_rec.api_name := l_api_name;
635 l_error_rec.api_package := G_PKG_NAME;
636 l_error_rec.idx := i;
637 validate_row (
638 p_api_version => p_api_version,
639 p_init_msg_list => OKC_API.G_FALSE,
640 x_return_status => l_error_rec.error_type,
641 x_msg_count => l_error_rec.msg_count,
642 x_msg_data => l_error_rec.msg_data,
643 p_oks_coverage_timezones_v_rec => p_oks_coverage_timezones_v_tbl(i));
644 IF (l_error_rec.error_type <> OKC_API.G_RET_STS_SUCCESS) THEN
645 l_error_rec.sqlcode := SQLCODE;
646 load_error_tbl(l_error_rec, px_error_tbl);
647 ELSE
648 x_msg_count := l_error_rec.msg_count;
649 x_msg_data := l_error_rec.msg_data;
650 END IF;
651 EXCEPTION
652 WHEN OKC_API.G_EXCEPTION_ERROR THEN
653 l_error_rec.error_type := OKC_API.G_RET_STS_ERROR;
654 l_error_rec.sqlcode := SQLCODE;
655 load_error_tbl(l_error_rec, px_error_tbl);
656 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
657 l_error_rec.error_type := OKC_API.G_RET_STS_UNEXP_ERROR;
658 l_error_rec.sqlcode := SQLCODE;
659 load_error_tbl(l_error_rec, px_error_tbl);
660 WHEN OTHERS THEN
661 l_error_rec.error_type := 'OTHERS';
662 l_error_rec.sqlcode := SQLCODE;
663 load_error_tbl(l_error_rec, px_error_tbl);
664 END;
665 EXIT WHEN (i = p_oks_coverage_timezones_v_tbl.LAST);
666 i := p_oks_coverage_timezones_v_tbl.NEXT(i);
667 END LOOP;
668 END IF;
669 -- Loop through the error_tbl to find the error with the highest severity
670 -- and return it.
671 x_return_status := find_highest_exception(px_error_tbl);
672 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
673 EXCEPTION
674 WHEN OKC_API.G_EXCEPTION_ERROR THEN
675 x_return_status := OKC_API.HANDLE_EXCEPTIONS
676 (
677 l_api_name,
678 G_PKG_NAME,
679 'OKC_API.G_RET_STS_ERROR',
680 x_msg_count,
681 x_msg_data,
682 '_PVT'
683 );
684 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
685 x_return_status := OKC_API.HANDLE_EXCEPTIONS
686 (
687 l_api_name,
688 G_PKG_NAME,
689 'OKC_API.G_RET_STS_UNEXP_ERROR',
690 x_msg_count,
691 x_msg_data,
692 '_PVT'
693 );
694 WHEN OTHERS THEN
695 x_return_status := OKC_API.HANDLE_EXCEPTIONS
696 (
697 l_api_name,
698 G_PKG_NAME,
699 'OTHERS',
700 x_msg_count,
701 x_msg_data,
702 '_PVT'
703 );
704 END validate_row;
705
706 ----------------------------------------------------------
707 -- PL/SQL TBL validate_row for:OKS_COVERAGE_TIMEZONES_V --
708 ----------------------------------------------------------
709 PROCEDURE validate_row(
710 p_api_version IN NUMBER,
711 p_init_msg_list IN VARCHAR2,
712 x_return_status OUT NOCOPY VARCHAR2,
713 x_msg_count OUT NOCOPY NUMBER,
714 x_msg_data OUT NOCOPY VARCHAR2,
715 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType) IS
716
717 l_api_version CONSTANT NUMBER := 1;
718 l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
719 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
720 l_error_tbl OKC_API.ERROR_TBL_TYPE;
721 BEGIN
722 OKC_API.init_msg_list(p_init_msg_list);
723 -- Make sure PL/SQL table has records in it before passing
724 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
725 validate_row (
726 p_api_version => p_api_version,
727 p_init_msg_list => OKC_API.G_FALSE,
728 x_return_status => x_return_status,
729 x_msg_count => x_msg_count,
730 x_msg_data => x_msg_data,
731 p_oks_coverage_timezones_v_tbl => p_oks_coverage_timezones_v_tbl,
732 px_error_tbl => l_error_tbl);
733 END IF;
734 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
735 EXCEPTION
736 WHEN OKC_API.G_EXCEPTION_ERROR THEN
737 x_return_status := OKC_API.HANDLE_EXCEPTIONS
738 (
739 l_api_name,
740 G_PKG_NAME,
741 'OKC_API.G_RET_STS_ERROR',
742 x_msg_count,
743 x_msg_data,
744 '_PVT'
745 );
746 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
747 x_return_status := OKC_API.HANDLE_EXCEPTIONS
748 (
749 l_api_name,
750 G_PKG_NAME,
751 'OKC_API.G_RET_STS_UNEXP_ERROR',
752 x_msg_count,
753 x_msg_data,
754 '_PVT'
755 );
756 WHEN OTHERS THEN
757 x_return_status := OKC_API.HANDLE_EXCEPTIONS
758 (
759 l_api_name,
760 G_PKG_NAME,
761 'OTHERS',
762 x_msg_count,
763 x_msg_data,
764 '_PVT'
765 );
766 END validate_row;
767
768 ---------------------------------------------------------------------------
769 -- PROCEDURE insert_row
770 ---------------------------------------------------------------------------
771 -------------------------------------------
772 -- insert_row for:OKS_COVERAGE_TIMEZONES --
773 -------------------------------------------
774 PROCEDURE insert_row(
775 p_init_msg_list IN VARCHAR2,
776 x_return_status OUT NOCOPY VARCHAR2,
777 x_msg_count OUT NOCOPY NUMBER,
778 x_msg_data OUT NOCOPY VARCHAR2,
779 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType,
780 x_oks_coverage_timezones_rec OUT NOCOPY OksCoverageTimezonesRecType) IS
781
782 l_api_version CONSTANT NUMBER := 1;
783 l_api_name CONSTANT VARCHAR2(30) := 'B_insert_row';
784 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
785 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType := p_oks_coverage_timezones_rec;
786 LDefOksCoverageTimezonesRec OksCoverageTimezonesRecType;
787 -----------------------------------------------
788 -- Set_Attributes for:OKS_COVERAGE_TIMEZONES --
789 -----------------------------------------------
790 FUNCTION Set_Attributes (
791 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType,
792 x_oks_coverage_timezones_rec OUT NOCOPY OksCoverageTimezonesRecType
793 ) RETURN VARCHAR2 IS
794 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
795 BEGIN
796 x_oks_coverage_timezones_rec := p_oks_coverage_timezones_rec;
797 RETURN(l_return_status);
798 END Set_Attributes;
799 BEGIN
800 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
801 p_init_msg_list,
802 '_PVT',
803 x_return_status);
804 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
805 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
806 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
807 RAISE OKC_API.G_EXCEPTION_ERROR;
808 END IF;
809 --- Setting item atributes
810 l_return_status := Set_Attributes(
811 p_oks_coverage_timezones_rec, -- IN
812 l_oks_coverage_timezones_rec); -- OUT
813 --- If any errors happen abort API
814 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
815 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
816 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
817 RAISE OKC_API.G_EXCEPTION_ERROR;
818 END IF;
819 INSERT INTO OKS_COVERAGE_TIMEZONES(
820 id,
821 cle_id,
822 default_yn,
823 timezone_id,
824 dnz_chr_id,
825 program_application_id,
826 program_id,
827 program_update_date,
828 request_id,
829 created_by,
830 creation_date,
831 last_updated_by,
832 last_update_date,
833 last_update_login,
834 object_version_number,
835 -- R12 Data Model Changes 4485150 Start
836 orig_system_id1,
837 orig_system_reference1,
838 orig_system_source_code
839 -- R12 Data Model Changes 4485150 End
840 )
841 VALUES (
842 l_oks_coverage_timezones_rec.id,
843 l_oks_coverage_timezones_rec.cle_id,
844 l_oks_coverage_timezones_rec.default_yn,
845 l_oks_coverage_timezones_rec.timezone_id,
846 l_oks_coverage_timezones_rec.dnz_chr_id,
847 l_oks_coverage_timezones_rec.program_application_id,
848 l_oks_coverage_timezones_rec.program_id,
849 l_oks_coverage_timezones_rec.program_update_date,
850 l_oks_coverage_timezones_rec.request_id,
851 l_oks_coverage_timezones_rec.created_by,
852 l_oks_coverage_timezones_rec.creation_date,
853 l_oks_coverage_timezones_rec.last_updated_by,
854 l_oks_coverage_timezones_rec.last_update_date,
855 l_oks_coverage_timezones_rec.last_update_login,
856 l_oks_coverage_timezones_rec.object_version_number,
857 -- R12 Data Model Changes 4485150 Start
858 l_oks_coverage_timezones_rec.orig_system_id1,
859 l_oks_coverage_timezones_rec.orig_system_reference1,
860 l_oks_coverage_timezones_rec.orig_system_source_code
861 -- R12 Data Model Changes 4485150 End
862 );
863 -- Set OUT values
864 x_oks_coverage_timezones_rec := l_oks_coverage_timezones_rec;
865 x_return_status := l_return_status;
866 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
867 EXCEPTION
868 WHEN OKC_API.G_EXCEPTION_ERROR THEN
869 x_return_status := OKC_API.HANDLE_EXCEPTIONS
870 (
871 l_api_name,
872 G_PKG_NAME,
873 'OKC_API.G_RET_STS_ERROR',
874 x_msg_count,
875 x_msg_data,
876 '_PVT'
877 );
878 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
879 x_return_status := OKC_API.HANDLE_EXCEPTIONS
880 (
881 l_api_name,
882 G_PKG_NAME,
883 'OKC_API.G_RET_STS_UNEXP_ERROR',
884 x_msg_count,
885 x_msg_data,
886 '_PVT'
887 );
888 WHEN OTHERS THEN
889 x_return_status := OKC_API.HANDLE_EXCEPTIONS
890 (
891 l_api_name,
892 G_PKG_NAME,
893 'OTHERS',
894 x_msg_count,
895 x_msg_data,
896 '_PVT'
897 );
898 END insert_row;
899 ----------------------------------------------
900 -- insert_row for :OKS_COVERAGE_TIMEZONES_V --
901 ----------------------------------------------
902 PROCEDURE insert_row(
903 p_api_version IN NUMBER,
904 p_init_msg_list IN VARCHAR2,
905 x_return_status OUT NOCOPY VARCHAR2,
906 x_msg_count OUT NOCOPY NUMBER,
907 x_msg_data OUT NOCOPY VARCHAR2,
908 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
909 x_oks_coverage_timezones_v_rec OUT NOCOPY OksCoverageTimezonesVRecType) IS
910
911 l_api_version CONSTANT NUMBER := 1;
912 l_api_name CONSTANT VARCHAR2(30) := 'V_insert_row';
913 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
914 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType := p_oks_coverage_timezones_v_rec;
915 LDefOksCoverageTimezonesVRec OksCoverageTimezonesVRecType;
916 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
917 lx_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
918 -------------------------------
919 -- FUNCTION fill_who_columns --
920 -------------------------------
921 FUNCTION fill_who_columns (
922 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType
923 ) RETURN OksCoverageTimezonesVRecType IS
924 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType := p_oks_coverage_timezones_v_rec;
925 BEGIN
926 l_oks_coverage_timezones_v_rec.CREATION_DATE := SYSDATE;
927 l_oks_coverage_timezones_v_rec.CREATED_BY := FND_GLOBAL.USER_ID;
928 l_oks_coverage_timezones_v_rec.LAST_UPDATE_DATE := l_oks_coverage_timezones_v_rec.CREATION_DATE;
929 l_oks_coverage_timezones_v_rec.LAST_UPDATED_BY := FND_GLOBAL.USER_ID;
930 l_oks_coverage_timezones_v_rec.LAST_UPDATE_LOGIN := FND_GLOBAL.LOGIN_ID;
931 RETURN(l_oks_coverage_timezones_v_rec);
932 END fill_who_columns;
933 -------------------------------------------------
934 -- Set_Attributes for:OKS_COVERAGE_TIMEZONES_V --
935 -------------------------------------------------
936 FUNCTION Set_Attributes (
937 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
938 x_oks_coverage_timezones_v_rec OUT NOCOPY OksCoverageTimezonesVRecType
939 ) RETURN VARCHAR2 IS
940 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
941 BEGIN
942 x_oks_coverage_timezones_v_rec := p_oks_coverage_timezones_v_rec;
943 x_oks_coverage_timezones_v_rec.OBJECT_VERSION_NUMBER := 1;
944 RETURN(l_return_status);
945 END Set_Attributes;
946 BEGIN
947 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
948 G_PKG_NAME,
949 p_init_msg_list,
950 l_api_version,
951 p_api_version,
952 '_PVT',
953 x_return_status);
954 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
955 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
956 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
957 RAISE OKC_API.G_EXCEPTION_ERROR;
958 END IF;
959 l_oks_coverage_timezones_v_rec := null_out_defaults(p_oks_coverage_timezones_v_rec);
960 -- Set primary key value
961 l_oks_coverage_timezones_v_rec.ID := get_seq_id;
962 -- Setting item attributes
963 l_return_Status := Set_Attributes(
964 l_oks_coverage_timezones_v_rec, -- IN
965 LDefOksCoverageTimezonesVRec); -- OUT
966 --- If any errors happen abort API
967 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
968 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
969 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
970 RAISE OKC_API.G_EXCEPTION_ERROR;
971 END IF;
972 LDefOksCoverageTimezonesVRec := fill_who_columns(LDefOksCoverageTimezonesVRec);
973 --- Validate all non-missing attributes (Item Level Validation)
974 l_return_status := Validate_Attributes(LDefOksCoverageTimezonesVRec);
975 --- If any errors happen abort API
976 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
977 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
978 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
979 RAISE OKC_API.G_EXCEPTION_ERROR;
980 END IF;
981 l_return_status := Validate_Record(LDefOksCoverageTimezonesVRec);
982 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
983 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
984 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
985 RAISE OKC_API.G_EXCEPTION_ERROR;
986 END IF;
987 -----------------------------------------
988 -- Move VIEW record to "Child" records --
989 -----------------------------------------
990 migrate(LDefOksCoverageTimezonesVRec, l_oks_coverage_timezones_rec);
991 -----------------------------------------------
992 -- Call the INSERT_ROW for each child record --
993 -----------------------------------------------
994 insert_row(
995 p_init_msg_list,
996 l_return_status,
997 x_msg_count,
998 x_msg_data,
999 l_oks_coverage_timezones_rec,
1000 lx_oks_coverage_timezones_rec
1001 );
1002 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1003 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1004 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1005 RAISE OKC_API.G_EXCEPTION_ERROR;
1006 END IF;
1007 migrate(lx_oks_coverage_timezones_rec, LDefOksCoverageTimezonesVRec);
1008 -- Set OUT values
1009 x_oks_coverage_timezones_v_rec := LDefOksCoverageTimezonesVRec;
1010 x_return_status := l_return_status;
1011 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1012 EXCEPTION
1013 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1014 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1015 (
1016 l_api_name,
1017 G_PKG_NAME,
1018 'OKC_API.G_RET_STS_ERROR',
1019 x_msg_count,
1020 x_msg_data,
1021 '_PVT'
1022 );
1023 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1024 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1025 (
1026 l_api_name,
1027 G_PKG_NAME,
1028 'OKC_API.G_RET_STS_UNEXP_ERROR',
1029 x_msg_count,
1030 x_msg_data,
1031 '_PVT'
1032 );
1033 WHEN OTHERS THEN
1034 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1035 (
1036 l_api_name,
1037 G_PKG_NAME,
1038 'OTHERS',
1039 x_msg_count,
1040 x_msg_data,
1041 '_PVT'
1042 );
1043 END insert_row;
1044 ------------------------------------------------------------
1045 -- PL/SQL TBL insert_row for:OKS_COVERAGE_TIMEZONES_V_TBL --
1046 ------------------------------------------------------------
1047 PROCEDURE insert_row(
1048 p_api_version IN NUMBER,
1049 p_init_msg_list IN VARCHAR2,
1050 x_return_status OUT NOCOPY VARCHAR2,
1051 x_msg_count OUT NOCOPY NUMBER,
1052 x_msg_data OUT NOCOPY VARCHAR2,
1053 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType,
1054 x_oks_coverage_timezones_v_tbl OUT NOCOPY OksCoverageTimezonesVTblType,
1055 px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
1056
1057 l_api_version CONSTANT NUMBER := 1;
1058 l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_insert_row';
1059 i NUMBER := 0;
1060 BEGIN
1061 OKC_API.init_msg_list(p_init_msg_list);
1062 -- Make sure PL/SQL table has records in it before passing
1063 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
1064 i := p_oks_coverage_timezones_v_tbl.FIRST;
1065 LOOP
1066 DECLARE
1067 l_error_rec OKC_API.ERROR_REC_TYPE;
1068 BEGIN
1069 l_error_rec.api_name := l_api_name;
1070 l_error_rec.api_package := G_PKG_NAME;
1071 l_error_rec.idx := i;
1072 insert_row (
1073 p_api_version => p_api_version,
1074 p_init_msg_list => OKC_API.G_FALSE,
1075 x_return_status => l_error_rec.error_type,
1076 x_msg_count => l_error_rec.msg_count,
1077 x_msg_data => l_error_rec.msg_data,
1078 p_oks_coverage_timezones_v_rec => p_oks_coverage_timezones_v_tbl(i),
1079 x_oks_coverage_timezones_v_rec => x_oks_coverage_timezones_v_tbl(i));
1080 IF (l_error_rec.error_type <> OKC_API.G_RET_STS_SUCCESS) THEN
1081 l_error_rec.sqlcode := SQLCODE;
1082 load_error_tbl(l_error_rec, px_error_tbl);
1083 ELSE
1084 x_msg_count := l_error_rec.msg_count;
1085 x_msg_data := l_error_rec.msg_data;
1086 END IF;
1087 EXCEPTION
1088 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1089 l_error_rec.error_type := OKC_API.G_RET_STS_ERROR;
1090 l_error_rec.sqlcode := SQLCODE;
1091 load_error_tbl(l_error_rec, px_error_tbl);
1092 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1093 l_error_rec.error_type := OKC_API.G_RET_STS_UNEXP_ERROR;
1094 l_error_rec.sqlcode := SQLCODE;
1095 load_error_tbl(l_error_rec, px_error_tbl);
1096 WHEN OTHERS THEN
1097 l_error_rec.error_type := 'OTHERS';
1098 l_error_rec.sqlcode := SQLCODE;
1099 load_error_tbl(l_error_rec, px_error_tbl);
1100 END;
1101 EXIT WHEN (i = p_oks_coverage_timezones_v_tbl.LAST);
1102 i := p_oks_coverage_timezones_v_tbl.NEXT(i);
1103 END LOOP;
1104 END IF;
1105 -- Loop through the error_tbl to find the error with the highest severity
1106 -- and return it.
1107 x_return_status := find_highest_exception(px_error_tbl);
1108 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1109 EXCEPTION
1110 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1111 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1112 (
1113 l_api_name,
1114 G_PKG_NAME,
1115 'OKC_API.G_RET_STS_ERROR',
1116 x_msg_count,
1117 x_msg_data,
1118 '_PVT'
1119 );
1120 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1121 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1122 (
1123 l_api_name,
1124 G_PKG_NAME,
1125 'OKC_API.G_RET_STS_UNEXP_ERROR',
1126 x_msg_count,
1127 x_msg_data,
1128 '_PVT'
1129 );
1130 WHEN OTHERS THEN
1131 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1132 (
1133 l_api_name,
1134 G_PKG_NAME,
1135 'OTHERS',
1136 x_msg_count,
1137 x_msg_data,
1138 '_PVT'
1139 );
1140 END insert_row;
1141
1142 ------------------------------------------------------------
1143 -- PL/SQL TBL insert_row for:OKS_COVERAGE_TIMEZONES_V_TBL --
1144 ------------------------------------------------------------
1145 -- This procedure is the same as the one above except it does not have a "px_error_tbl" argument.
1146 -- This procedure was create for backward compatibility and simply is a wrapper for the one above.
1147 PROCEDURE insert_row(
1148 p_api_version IN NUMBER,
1149 p_init_msg_list IN VARCHAR2,
1150 x_return_status OUT NOCOPY VARCHAR2,
1151 x_msg_count OUT NOCOPY NUMBER,
1152 x_msg_data OUT NOCOPY VARCHAR2,
1153 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType,
1154 x_oks_coverage_timezones_v_tbl OUT NOCOPY OksCoverageTimezonesVTblType) IS
1155
1156 l_api_version CONSTANT NUMBER := 1;
1157 l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
1158 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1159 l_error_tbl OKC_API.ERROR_TBL_TYPE;
1160 BEGIN
1161 OKC_API.init_msg_list(p_init_msg_list);
1162 -- Make sure PL/SQL table has records in it before passing
1163 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
1164 insert_row (
1165 p_api_version => p_api_version,
1166 p_init_msg_list => OKC_API.G_FALSE,
1167 x_return_status => x_return_status,
1168 x_msg_count => x_msg_count,
1169 x_msg_data => x_msg_data,
1170 p_oks_coverage_timezones_v_tbl => p_oks_coverage_timezones_v_tbl,
1171 x_oks_coverage_timezones_v_tbl => x_oks_coverage_timezones_v_tbl,
1172 px_error_tbl => l_error_tbl);
1173 END IF;
1174 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1175 EXCEPTION
1176 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1177 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1178 (
1179 l_api_name,
1180 G_PKG_NAME,
1181 'OKC_API.G_RET_STS_ERROR',
1182 x_msg_count,
1183 x_msg_data,
1184 '_PVT'
1185 );
1186 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1187 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1188 (
1189 l_api_name,
1190 G_PKG_NAME,
1191 'OKC_API.G_RET_STS_UNEXP_ERROR',
1192 x_msg_count,
1193 x_msg_data,
1194 '_PVT'
1195 );
1196 WHEN OTHERS THEN
1197 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1198 (
1199 l_api_name,
1200 G_PKG_NAME,
1201 'OTHERS',
1202 x_msg_count,
1203 x_msg_data,
1204 '_PVT'
1205 );
1206 END insert_row;
1207
1208 ---------------------------------------------------------------------------
1209 -- PROCEDURE lock_row
1210 ---------------------------------------------------------------------------
1211 -----------------------------------------
1212 -- lock_row for:OKS_COVERAGE_TIMEZONES --
1213 -----------------------------------------
1214 PROCEDURE lock_row(
1215 p_init_msg_list IN VARCHAR2,
1216 x_return_status OUT NOCOPY VARCHAR2,
1217 x_msg_count OUT NOCOPY NUMBER,
1218 x_msg_data OUT NOCOPY VARCHAR2,
1219 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType) IS
1220
1221 E_Resource_Busy EXCEPTION;
1222 PRAGMA EXCEPTION_INIT(E_Resource_Busy, -00054);
1223 CURSOR lock_csr (p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType) IS
1224 SELECT OBJECT_VERSION_NUMBER
1225 FROM OKS_COVERAGE_TIMEZONES
1226 WHERE ID = p_oks_coverage_timezones_rec.id
1227 AND OBJECT_VERSION_NUMBER = p_oks_coverage_timezones_rec.object_version_number
1228 FOR UPDATE OF OBJECT_VERSION_NUMBER NOWAIT;
1229
1230 CURSOR lchk_csr (p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType) IS
1231 SELECT OBJECT_VERSION_NUMBER
1232 FROM OKS_COVERAGE_TIMEZONES
1233 WHERE ID = p_oks_coverage_timezones_rec.id;
1234 l_api_version CONSTANT NUMBER := 1;
1235 l_api_name CONSTANT VARCHAR2(30) := 'B_lock_row';
1236 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1237 l_object_version_number OKS_COVERAGE_TIMEZONES.OBJECT_VERSION_NUMBER%TYPE;
1238 lc_object_version_number OKS_COVERAGE_TIMEZONES.OBJECT_VERSION_NUMBER%TYPE;
1239 l_row_notfound BOOLEAN := FALSE;
1240 lc_row_notfound BOOLEAN := FALSE;
1241 BEGIN
1242 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1243 p_init_msg_list,
1244 '_PVT',
1245 x_return_status);
1246 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1247 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1248 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1249 RAISE OKC_API.G_EXCEPTION_ERROR;
1250 END IF;
1251 BEGIN
1252 OPEN lock_csr(p_oks_coverage_timezones_rec);
1253 FETCH lock_csr INTO l_object_version_number;
1254 l_row_notfound := lock_csr%NOTFOUND;
1255 CLOSE lock_csr;
1256 EXCEPTION
1257 WHEN E_Resource_Busy THEN
1258 IF (lock_csr%ISOPEN) THEN
1259 CLOSE lock_csr;
1260 END IF;
1261 OKC_API.set_message(G_FND_APP,G_FORM_UNABLE_TO_RESERVE_REC);
1262 RAISE APP_EXCEPTIONS.RECORD_LOCK_EXCEPTION;
1263 END;
1264
1265 IF ( l_row_notfound ) THEN
1266 OPEN lchk_csr(p_oks_coverage_timezones_rec);
1267 FETCH lchk_csr INTO lc_object_version_number;
1268 lc_row_notfound := lchk_csr%NOTFOUND;
1269 CLOSE lchk_csr;
1270 END IF;
1271 IF (lc_row_notfound) THEN
1272 OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1273 RAISE OKC_API.G_EXCEPTION_ERROR;
1274 ELSIF lc_object_version_number > p_oks_coverage_timezones_rec.object_version_number THEN
1275 OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1276 RAISE OKC_API.G_EXCEPTION_ERROR;
1277 ELSIF lc_object_version_number <> p_oks_coverage_timezones_rec.object_version_number THEN
1278 OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1279 RAISE OKC_API.G_EXCEPTION_ERROR;
1280 ELSIF lc_object_version_number = -1 THEN
1281 OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1282 RAISE OKC_API.G_EXCEPTION_ERROR;
1283 END IF;
1284 x_return_status := l_return_status;
1285 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1286 EXCEPTION
1287 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1288 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1289 (
1290 l_api_name,
1291 G_PKG_NAME,
1292 'OKC_API.G_RET_STS_ERROR',
1293 x_msg_count,
1294 x_msg_data,
1295 '_PVT'
1296 );
1297 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1298 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1299 (
1300 l_api_name,
1301 G_PKG_NAME,
1302 'OKC_API.G_RET_STS_UNEXP_ERROR',
1303 x_msg_count,
1304 x_msg_data,
1305 '_PVT'
1306 );
1307 WHEN OTHERS THEN
1308 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1309 (
1310 l_api_name,
1311 G_PKG_NAME,
1312 'OTHERS',
1313 x_msg_count,
1314 x_msg_data,
1315 '_PVT'
1316 );
1317 END lock_row;
1318 --------------------------------------------
1319 -- lock_row for: OKS_COVERAGE_TIMEZONES_V --
1320 --------------------------------------------
1321 PROCEDURE lock_row(
1322 p_api_version IN NUMBER,
1323 p_init_msg_list IN VARCHAR2,
1324 x_return_status OUT NOCOPY VARCHAR2,
1325 x_msg_count OUT NOCOPY NUMBER,
1326 x_msg_data OUT NOCOPY VARCHAR2,
1327 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType) IS
1328
1329 l_api_version CONSTANT NUMBER := 1;
1330 l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
1331 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1332 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
1333 BEGIN
1334 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1335 G_PKG_NAME,
1336 p_init_msg_list,
1337 l_api_version,
1338 p_api_version,
1339 '_PVT',
1340 x_return_status);
1341 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1342 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1343 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1344 RAISE OKC_API.G_EXCEPTION_ERROR;
1345 END IF;
1346 -----------------------------------------
1347 -- Move VIEW record to "Child" records --
1348 -----------------------------------------
1349 migrate(p_oks_coverage_timezones_v_rec, l_oks_coverage_timezones_rec);
1350 ---------------------------------------------
1351 -- Call the LOCK_ROW for each child record --
1352 ---------------------------------------------
1353 lock_row(
1354 p_init_msg_list,
1355 l_return_status,
1356 x_msg_count,
1357 x_msg_data,
1358 l_oks_coverage_timezones_rec
1359 );
1360 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1361 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1362 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1363 RAISE OKC_API.G_EXCEPTION_ERROR;
1364 END IF;
1365 x_return_status := l_return_status;
1366 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1367 EXCEPTION
1368 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1369 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1370 (
1371 l_api_name,
1372 G_PKG_NAME,
1373 'OKC_API.G_RET_STS_ERROR',
1374 x_msg_count,
1375 x_msg_data,
1376 '_PVT'
1377 );
1378 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1379 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1380 (
1381 l_api_name,
1382 G_PKG_NAME,
1383 'OKC_API.G_RET_STS_UNEXP_ERROR',
1384 x_msg_count,
1385 x_msg_data,
1386 '_PVT'
1387 );
1388 WHEN OTHERS THEN
1389 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1390 (
1391 l_api_name,
1392 G_PKG_NAME,
1393 'OTHERS',
1394 x_msg_count,
1395 x_msg_data,
1396 '_PVT'
1397 );
1398 END lock_row;
1399 ----------------------------------------------------------
1400 -- PL/SQL TBL lock_row for:OKS_COVERAGE_TIMEZONES_V_TBL --
1401 ----------------------------------------------------------
1402 PROCEDURE lock_row(
1403 p_api_version IN NUMBER,
1404 p_init_msg_list IN VARCHAR2,
1405 x_return_status OUT NOCOPY VARCHAR2,
1406 x_msg_count OUT NOCOPY NUMBER,
1407 x_msg_data OUT NOCOPY VARCHAR2,
1408 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType,
1409 px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
1410
1411 l_api_version CONSTANT NUMBER := 1;
1412 l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_lock_row';
1413 i NUMBER := 0;
1414 BEGIN
1415 OKC_API.init_msg_list(p_init_msg_list);
1416 -- Make sure PL/SQL table has recrods in it before passing
1417 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
1418 i := p_oks_coverage_timezones_v_tbl.FIRST;
1419 LOOP
1420 DECLARE
1421 l_error_rec OKC_API.ERROR_REC_TYPE;
1422 BEGIN
1423 l_error_rec.api_name := l_api_name;
1424 l_error_rec.api_package := G_PKG_NAME;
1425 l_error_rec.idx := i;
1426 lock_row(
1427 p_api_version => p_api_version,
1428 p_init_msg_list => OKC_API.G_FALSE,
1429 x_return_status => l_error_rec.error_type,
1430 x_msg_count => l_error_rec.msg_count,
1431 x_msg_data => l_error_rec.msg_data,
1432 p_oks_coverage_timezones_v_rec => p_oks_coverage_timezones_v_tbl(i));
1433 IF (l_error_rec.error_type <> OKC_API.G_RET_STS_SUCCESS) THEN
1434 l_error_rec.sqlcode := SQLCODE;
1435 load_error_tbl(l_error_rec, px_error_tbl);
1436 ELSE
1437 x_msg_count := l_error_rec.msg_count;
1438 x_msg_data := l_error_rec.msg_data;
1439 END IF;
1440 EXCEPTION
1441 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1442 l_error_rec.error_type := OKC_API.G_RET_STS_ERROR;
1443 l_error_rec.sqlcode := SQLCODE;
1444 load_error_tbl(l_error_rec, px_error_tbl);
1445 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1446 l_error_rec.error_type := OKC_API.G_RET_STS_UNEXP_ERROR;
1447 l_error_rec.sqlcode := SQLCODE;
1448 load_error_tbl(l_error_rec, px_error_tbl);
1449 WHEN OTHERS THEN
1450 l_error_rec.error_type := 'OTHERS';
1451 l_error_rec.sqlcode := SQLCODE;
1452 load_error_tbl(l_error_rec, px_error_tbl);
1453 END;
1454 EXIT WHEN (i = p_oks_coverage_timezones_v_tbl.LAST);
1455 i := p_oks_coverage_timezones_v_tbl.NEXT(i);
1456 END LOOP;
1457 END IF;
1458 -- Loop through the error_tbl to find the error with the highest severity
1459 -- and return it.
1460 x_return_status := find_highest_exception(px_error_tbl);
1461 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1462 EXCEPTION
1463 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1464 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1465 (
1466 l_api_name,
1467 G_PKG_NAME,
1468 'OKC_API.G_RET_STS_ERROR',
1469 x_msg_count,
1470 x_msg_data,
1471 '_PVT'
1472 );
1473 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1474 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1475 (
1476 l_api_name,
1477 G_PKG_NAME,
1478 'OKC_API.G_RET_STS_UNEXP_ERROR',
1479 x_msg_count,
1480 x_msg_data,
1481 '_PVT'
1482 );
1483 WHEN OTHERS THEN
1484 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1485 (
1486 l_api_name,
1487 G_PKG_NAME,
1488 'OTHERS',
1489 x_msg_count,
1490 x_msg_data,
1491 '_PVT'
1492 );
1493 END lock_row;
1494 ----------------------------------------------------------
1495 -- PL/SQL TBL lock_row for:OKS_COVERAGE_TIMEZONES_V_TBL --
1496 ----------------------------------------------------------
1497 PROCEDURE lock_row(
1498 p_api_version IN NUMBER,
1499 p_init_msg_list IN VARCHAR2,
1500 x_return_status OUT NOCOPY VARCHAR2,
1501 x_msg_count OUT NOCOPY NUMBER,
1502 x_msg_data OUT NOCOPY VARCHAR2,
1503 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType) IS
1504
1505 l_api_version CONSTANT NUMBER := 1;
1506 l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
1507 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1508 l_error_tbl OKC_API.ERROR_TBL_TYPE;
1509 BEGIN
1510 OKC_API.init_msg_list(p_init_msg_list);
1511 -- Make sure PL/SQL table has recrods in it before passing
1512 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
1513 lock_row(
1514 p_api_version => p_api_version,
1515 p_init_msg_list => OKC_API.G_FALSE,
1516 x_return_status => x_return_status,
1517 x_msg_count => x_msg_count,
1518 x_msg_data => x_msg_data,
1519 p_oks_coverage_timezones_v_tbl => p_oks_coverage_timezones_v_tbl,
1520 px_error_tbl => l_error_tbl);
1521 END IF;
1522 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1523 EXCEPTION
1524 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1525 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1526 (
1527 l_api_name,
1528 G_PKG_NAME,
1529 'OKC_API.G_RET_STS_ERROR',
1530 x_msg_count,
1531 x_msg_data,
1532 '_PVT'
1533 );
1534 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1535 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1536 (
1537 l_api_name,
1538 G_PKG_NAME,
1539 'OKC_API.G_RET_STS_UNEXP_ERROR',
1540 x_msg_count,
1541 x_msg_data,
1542 '_PVT'
1543 );
1544 WHEN OTHERS THEN
1545 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1546 (
1547 l_api_name,
1548 G_PKG_NAME,
1549 'OTHERS',
1550 x_msg_count,
1551 x_msg_data,
1552 '_PVT'
1553 );
1554 END lock_row;
1555 ---------------------------------------------------------------------------
1556 -- PROCEDURE update_row
1557 ---------------------------------------------------------------------------
1558 -------------------------------------------
1559 -- update_row for:OKS_COVERAGE_TIMEZONES --
1560 -------------------------------------------
1561 PROCEDURE update_row(
1562 p_init_msg_list IN VARCHAR2,
1563 x_return_status OUT NOCOPY VARCHAR2,
1564 x_msg_count OUT NOCOPY NUMBER,
1565 x_msg_data OUT NOCOPY VARCHAR2,
1566 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType,
1567 x_oks_coverage_timezones_rec OUT NOCOPY OksCoverageTimezonesRecType) IS
1568
1569 l_api_version CONSTANT NUMBER := 1;
1570 l_api_name CONSTANT VARCHAR2(30) := 'B_update_row';
1571 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1572 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType := p_oks_coverage_timezones_rec;
1573 LDefOksCoverageTimezonesRec OksCoverageTimezonesRecType;
1574 l_row_notfound BOOLEAN := TRUE;
1575 ----------------------------------
1576 -- FUNCTION populate_new_record --
1577 ----------------------------------
1578 FUNCTION populate_new_record (
1579 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType,
1580 x_oks_coverage_timezones_rec OUT NOCOPY OksCoverageTimezonesRecType
1581 ) RETURN VARCHAR2 IS
1582 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
1583 l_row_notfound BOOLEAN := TRUE;
1584 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1585 BEGIN
1586 x_oks_coverage_timezones_rec := p_oks_coverage_timezones_rec;
1587 -- Get current database values
1588 l_oks_coverage_timezones_rec := get_rec(p_oks_coverage_timezones_rec, l_return_status);
1589 IF (l_return_status = OKC_API.G_RET_STS_SUCCESS) THEN
1590 IF (x_oks_coverage_timezones_rec.id = OKC_API.G_MISS_NUM)
1591 THEN
1592 x_oks_coverage_timezones_rec.id := l_oks_coverage_timezones_rec.id;
1593 END IF;
1594 IF (x_oks_coverage_timezones_rec.cle_id = OKC_API.G_MISS_NUM)
1595 THEN
1596 x_oks_coverage_timezones_rec.cle_id := l_oks_coverage_timezones_rec.cle_id;
1597 END IF;
1598 IF (x_oks_coverage_timezones_rec.default_yn = OKC_API.G_MISS_CHAR)
1599 THEN
1600 x_oks_coverage_timezones_rec.default_yn := l_oks_coverage_timezones_rec.default_yn;
1601 END IF;
1602 IF (x_oks_coverage_timezones_rec.timezone_id = OKC_API.G_MISS_NUM)
1603 THEN
1604 x_oks_coverage_timezones_rec.timezone_id := l_oks_coverage_timezones_rec.timezone_id;
1605 END IF;
1606 IF (x_oks_coverage_timezones_rec.dnz_chr_id = OKC_API.G_MISS_NUM)
1607 THEN
1608 x_oks_coverage_timezones_rec.dnz_chr_id := l_oks_coverage_timezones_rec.dnz_chr_id;
1609 END IF;
1610 IF (x_oks_coverage_timezones_rec.program_application_id = OKC_API.G_MISS_NUM)
1611 THEN
1612 x_oks_coverage_timezones_rec.program_application_id := l_oks_coverage_timezones_rec.program_application_id;
1613 END IF;
1614 IF (x_oks_coverage_timezones_rec.program_id = OKC_API.G_MISS_NUM)
1615 THEN
1616 x_oks_coverage_timezones_rec.program_id := l_oks_coverage_timezones_rec.program_id;
1617 END IF;
1618 IF (x_oks_coverage_timezones_rec.program_update_date = OKC_API.G_MISS_DATE)
1619 THEN
1620 x_oks_coverage_timezones_rec.program_update_date := l_oks_coverage_timezones_rec.program_update_date;
1621 END IF;
1622 IF (x_oks_coverage_timezones_rec.request_id = OKC_API.G_MISS_NUM)
1623 THEN
1624 x_oks_coverage_timezones_rec.request_id := l_oks_coverage_timezones_rec.request_id;
1625 END IF;
1626 IF (x_oks_coverage_timezones_rec.created_by = OKC_API.G_MISS_NUM)
1627 THEN
1628 x_oks_coverage_timezones_rec.created_by := l_oks_coverage_timezones_rec.created_by;
1629 END IF;
1630 IF (x_oks_coverage_timezones_rec.creation_date = OKC_API.G_MISS_DATE)
1631 THEN
1632 x_oks_coverage_timezones_rec.creation_date := l_oks_coverage_timezones_rec.creation_date;
1633 END IF;
1634 IF (x_oks_coverage_timezones_rec.last_updated_by = OKC_API.G_MISS_NUM)
1635 THEN
1636 x_oks_coverage_timezones_rec.last_updated_by := l_oks_coverage_timezones_rec.last_updated_by;
1637 END IF;
1638 IF (x_oks_coverage_timezones_rec.last_update_date = OKC_API.G_MISS_DATE)
1639 THEN
1640 x_oks_coverage_timezones_rec.last_update_date := l_oks_coverage_timezones_rec.last_update_date;
1641 END IF;
1642 IF (x_oks_coverage_timezones_rec.last_update_login = OKC_API.G_MISS_NUM)
1643 THEN
1644 x_oks_coverage_timezones_rec.last_update_login := l_oks_coverage_timezones_rec.last_update_login;
1645 END IF;
1646 IF (x_oks_coverage_timezones_rec.object_version_number = OKC_API.G_MISS_NUM)
1647 THEN
1648 x_oks_coverage_timezones_rec.object_version_number := l_oks_coverage_timezones_rec.object_version_number;
1649 END IF;
1650 -- R12 Data Model Changes 4485150 Start
1651 IF (x_oks_coverage_timezones_rec.orig_system_id1 = OKC_API.G_MISS_NUM)
1652 THEN
1653 x_oks_coverage_timezones_rec.orig_system_id1 := l_oks_coverage_timezones_rec.orig_system_id1;
1654 END IF;
1655 IF (x_oks_coverage_timezones_rec.orig_system_reference1 = OKC_API.G_MISS_CHAR)
1656 THEN
1657 x_oks_coverage_timezones_rec.orig_system_reference1 := l_oks_coverage_timezones_rec.orig_system_reference1;
1658 END IF;
1659 IF (x_oks_coverage_timezones_rec.orig_system_source_code = OKC_API.G_MISS_CHAR)
1660 THEN
1661 x_oks_coverage_timezones_rec.orig_system_source_code := l_oks_coverage_timezones_rec.orig_system_source_code;
1662 END IF;
1663 -- R12 Data Model Changes 4485150 End
1664 END IF;
1665 RETURN(l_return_status);
1666 END populate_new_record;
1667 -----------------------------------------------
1668 -- Set_Attributes for:OKS_COVERAGE_TIMEZONES --
1669 -----------------------------------------------
1670 FUNCTION Set_Attributes (
1671 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType,
1672 x_oks_coverage_timezones_rec OUT NOCOPY OksCoverageTimezonesRecType
1673 ) RETURN VARCHAR2 IS
1674 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1675 BEGIN
1676 x_oks_coverage_timezones_rec := p_oks_coverage_timezones_rec;
1677 x_oks_coverage_timezones_rec.OBJECT_VERSION_NUMBER := p_oks_coverage_timezones_rec.OBJECT_VERSION_NUMBER + 1;
1678 RETURN(l_return_status);
1679 END Set_Attributes;
1680 BEGIN
1681 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1682 p_init_msg_list,
1683 '_PVT',
1684 x_return_status);
1685 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1686 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1687 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1688 RAISE OKC_API.G_EXCEPTION_ERROR;
1689 END IF;
1690 --- Setting item attributes
1691 l_return_status := Set_Attributes(
1692 p_oks_coverage_timezones_rec, -- IN
1693 l_oks_coverage_timezones_rec); -- OUT
1694 --- If any errors happen abort API
1695 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1696 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1697 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1698 RAISE OKC_API.G_EXCEPTION_ERROR;
1699 END IF;
1700 l_return_status := populate_new_record(l_oks_coverage_timezones_rec, LDefOksCoverageTimezonesRec);
1701 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1702 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1703 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1704 RAISE OKC_API.G_EXCEPTION_ERROR;
1705 END IF;
1706 UPDATE OKS_COVERAGE_TIMEZONES
1707 SET CLE_ID = LDefOksCoverageTimezonesRec.cle_id,
1708 DEFAULT_YN = LDefOksCoverageTimezonesRec.default_yn,
1709 TIMEZONE_ID = LDefOksCoverageTimezonesRec.timezone_id,
1710 DNZ_CHR_ID = LDefOksCoverageTimezonesRec.dnz_chr_id,
1711 PROGRAM_APPLICATION_ID = LDefOksCoverageTimezonesRec.program_application_id,
1712 PROGRAM_ID = LDefOksCoverageTimezonesRec.program_id,
1713 PROGRAM_UPDATE_DATE = LDefOksCoverageTimezonesRec.program_update_date,
1714 REQUEST_ID = LDefOksCoverageTimezonesRec.request_id,
1715 CREATED_BY = LDefOksCoverageTimezonesRec.created_by,
1716 CREATION_DATE = LDefOksCoverageTimezonesRec.creation_date,
1717 LAST_UPDATED_BY = LDefOksCoverageTimezonesRec.last_updated_by,
1718 LAST_UPDATE_DATE = LDefOksCoverageTimezonesRec.last_update_date,
1719 LAST_UPDATE_LOGIN = LDefOksCoverageTimezonesRec.last_update_login,
1720 OBJECT_VERSION_NUMBER = LDefOksCoverageTimezonesRec.object_version_number,
1721 -- R12 Data Model Changes 4485150 Start
1722 ORIG_SYSTEM_ID1 = LDefOksCoverageTimezonesRec.orig_system_id1,
1723 ORIG_SYSTEM_REFERENCE1 = LDefOksCoverageTimezonesRec.orig_system_reference1,
1724 ORIG_SYSTEM_SOURCE_CODE = LDefOksCoverageTimezonesRec.orig_system_source_code
1725 -- R12 Data Model Changes 4485150 End
1726 WHERE ID = LDefOksCoverageTimezonesRec.id;
1727
1728 x_oks_coverage_timezones_rec := l_oks_coverage_timezones_rec;
1729 x_return_status := l_return_status;
1730 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1731 EXCEPTION
1732 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1733 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1734 (
1735 l_api_name,
1736 G_PKG_NAME,
1737 'OKC_API.G_RET_STS_ERROR',
1738 x_msg_count,
1739 x_msg_data,
1740 '_PVT'
1741 );
1742 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1743 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1744 (
1745 l_api_name,
1746 G_PKG_NAME,
1747 'OKC_API.G_RET_STS_UNEXP_ERROR',
1748 x_msg_count,
1749 x_msg_data,
1750 '_PVT'
1751 );
1752 WHEN OTHERS THEN
1753 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1754 (
1755 l_api_name,
1756 G_PKG_NAME,
1757 'OTHERS',
1758 x_msg_count,
1759 x_msg_data,
1760 '_PVT'
1761 );
1762 END update_row;
1763 ---------------------------------------------
1764 -- update_row for:OKS_COVERAGE_TIMEZONES_V --
1765 ---------------------------------------------
1766 PROCEDURE update_row(
1767 p_api_version IN NUMBER,
1768 p_init_msg_list IN VARCHAR2,
1769 x_return_status OUT NOCOPY VARCHAR2,
1770 x_msg_count OUT NOCOPY NUMBER,
1771 x_msg_data OUT NOCOPY VARCHAR2,
1772 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
1773 x_oks_coverage_timezones_v_rec OUT NOCOPY OksCoverageTimezonesVRecType) IS
1774
1775 l_api_version CONSTANT NUMBER := 1;
1776 l_api_name CONSTANT VARCHAR2(30) := 'V_update_row';
1777 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1778 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType := p_oks_coverage_timezones_v_rec;
1779 LDefOksCoverageTimezonesVRec OksCoverageTimezonesVRecType;
1780 l_db_oks_coverage_tim44 OksCoverageTimezonesVRecType;
1781 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
1782 lx_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
1783 -------------------------------
1784 -- FUNCTION fill_who_columns --
1785 -------------------------------
1786 FUNCTION fill_who_columns (
1787 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType
1788 ) RETURN OksCoverageTimezonesVRecType IS
1789 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType := p_oks_coverage_timezones_v_rec;
1790 BEGIN
1791 l_oks_coverage_timezones_v_rec.LAST_UPDATE_DATE := SYSDATE;
1792 l_oks_coverage_timezones_v_rec.LAST_UPDATED_BY := FND_GLOBAL.USER_ID;
1793 l_oks_coverage_timezones_v_rec.LAST_UPDATE_LOGIN := FND_GLOBAL.LOGIN_ID;
1794 RETURN(l_oks_coverage_timezones_v_rec);
1795 END fill_who_columns;
1796 ----------------------------------
1797 -- FUNCTION populate_new_record --
1798 ----------------------------------
1799 FUNCTION populate_new_record (
1800 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
1801 x_oks_coverage_timezones_v_rec OUT NOCOPY OksCoverageTimezonesVRecType
1802 ) RETURN VARCHAR2 IS
1803 l_row_notfound BOOLEAN := TRUE;
1804 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1805 BEGIN
1806 x_oks_coverage_timezones_v_rec := p_oks_coverage_timezones_v_rec;
1807 -- Get current database values
1808 -- NOTE: Never assign the OBJECT_VERSION_NUMBER. Force the user to pass it
1809 -- so it may be verified through LOCK_ROW.
1810 l_db_oks_coverage_tim44 := get_rec(p_oks_coverage_timezones_v_rec, l_return_status);
1811 IF (l_return_status = OKC_API.G_RET_STS_SUCCESS) THEN
1812 IF (x_oks_coverage_timezones_v_rec.id = OKC_API.G_MISS_NUM)
1813 THEN
1814 x_oks_coverage_timezones_v_rec.id := l_db_oks_coverage_tim44.id;
1815 END IF;
1816 IF (x_oks_coverage_timezones_v_rec.cle_id = OKC_API.G_MISS_NUM)
1817 THEN
1818 x_oks_coverage_timezones_v_rec.cle_id := l_db_oks_coverage_tim44.cle_id;
1819 END IF;
1820 IF (x_oks_coverage_timezones_v_rec.default_yn = OKC_API.G_MISS_CHAR)
1821 THEN
1822 x_oks_coverage_timezones_v_rec.default_yn := l_db_oks_coverage_tim44.default_yn;
1823 END IF;
1824 IF (x_oks_coverage_timezones_v_rec.timezone_id = OKC_API.G_MISS_NUM)
1825 THEN
1826 x_oks_coverage_timezones_v_rec.timezone_id := l_db_oks_coverage_tim44.timezone_id;
1827 END IF;
1828 IF (x_oks_coverage_timezones_v_rec.dnz_chr_id = OKC_API.G_MISS_NUM)
1829 THEN
1830 x_oks_coverage_timezones_v_rec.dnz_chr_id := l_db_oks_coverage_tim44.dnz_chr_id;
1831 END IF;
1832 IF (x_oks_coverage_timezones_v_rec.security_group_id = OKC_API.G_MISS_NUM)
1833 THEN
1834 x_oks_coverage_timezones_v_rec.security_group_id := l_db_oks_coverage_tim44.security_group_id;
1835 END IF;
1836 IF (x_oks_coverage_timezones_v_rec.program_application_id = OKC_API.G_MISS_NUM)
1837 THEN
1838 x_oks_coverage_timezones_v_rec.program_application_id := l_db_oks_coverage_tim44.program_application_id;
1839 END IF;
1840 IF (x_oks_coverage_timezones_v_rec.program_id = OKC_API.G_MISS_NUM)
1841 THEN
1842 x_oks_coverage_timezones_v_rec.program_id := l_db_oks_coverage_tim44.program_id;
1843 END IF;
1844 IF (x_oks_coverage_timezones_v_rec.program_update_date = OKC_API.G_MISS_DATE)
1845 THEN
1846 x_oks_coverage_timezones_v_rec.program_update_date := l_db_oks_coverage_tim44.program_update_date;
1847 END IF;
1848 IF (x_oks_coverage_timezones_v_rec.request_id = OKC_API.G_MISS_NUM)
1849 THEN
1850 x_oks_coverage_timezones_v_rec.request_id := l_db_oks_coverage_tim44.request_id;
1851 END IF;
1852 IF (x_oks_coverage_timezones_v_rec.created_by = OKC_API.G_MISS_NUM)
1853 THEN
1854 x_oks_coverage_timezones_v_rec.created_by := l_db_oks_coverage_tim44.created_by;
1855 END IF;
1856 IF (x_oks_coverage_timezones_v_rec.creation_date = OKC_API.G_MISS_DATE)
1857 THEN
1858 x_oks_coverage_timezones_v_rec.creation_date := l_db_oks_coverage_tim44.creation_date;
1859 END IF;
1860 IF (x_oks_coverage_timezones_v_rec.last_updated_by = OKC_API.G_MISS_NUM)
1861 THEN
1862 x_oks_coverage_timezones_v_rec.last_updated_by := l_db_oks_coverage_tim44.last_updated_by;
1863 END IF;
1864 IF (x_oks_coverage_timezones_v_rec.last_update_date = OKC_API.G_MISS_DATE)
1865 THEN
1866 x_oks_coverage_timezones_v_rec.last_update_date := l_db_oks_coverage_tim44.last_update_date;
1867 END IF;
1868 IF (x_oks_coverage_timezones_v_rec.last_update_login = OKC_API.G_MISS_NUM)
1869 THEN
1870 x_oks_coverage_timezones_v_rec.last_update_login := l_db_oks_coverage_tim44.last_update_login;
1871 END IF;
1872 -- R12 Data Model Changes 4485150 Start
1873 IF (x_oks_coverage_timezones_v_rec.orig_system_id1 = OKC_API.G_MISS_NUM)
1874 THEN
1875 x_oks_coverage_timezones_v_rec.orig_system_id1 := l_db_oks_coverage_tim44.orig_system_id1;
1876 END IF;
1877 IF (x_oks_coverage_timezones_v_rec.orig_system_reference1 = OKC_API.G_MISS_CHAR)
1878 THEN
1879 x_oks_coverage_timezones_v_rec.orig_system_reference1 := l_db_oks_coverage_tim44.orig_system_reference1;
1880 END IF;
1881 IF (x_oks_coverage_timezones_v_rec.orig_system_source_code = OKC_API.G_MISS_CHAR)
1882 THEN
1883 x_oks_coverage_timezones_v_rec.orig_system_source_code := l_db_oks_coverage_tim44.orig_system_source_code;
1884 END IF;
1885 -- R12 Data Model Changes 4485150 End
1886 END IF;
1887 RETURN(l_return_status);
1888 END populate_new_record;
1889 -------------------------------------------------
1890 -- Set_Attributes for:OKS_COVERAGE_TIMEZONES_V --
1891 -------------------------------------------------
1892 FUNCTION Set_Attributes (
1893 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType,
1894 x_oks_coverage_timezones_v_rec OUT NOCOPY OksCoverageTimezonesVRecType
1895 ) RETURN VARCHAR2 IS
1896 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1897 BEGIN
1898 x_oks_coverage_timezones_v_rec := p_oks_coverage_timezones_v_rec;
1899 RETURN(l_return_status);
1900 END Set_Attributes;
1901 BEGIN
1902 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1903 G_PKG_NAME,
1904 p_init_msg_list,
1905 l_api_version,
1906 p_api_version,
1907 '_PVT',
1908 x_return_status);
1909 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1910 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1911 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1912 RAISE OKC_API.G_EXCEPTION_ERROR;
1913 END IF;
1914 --- Setting item attributes
1915 l_return_status := Set_Attributes(
1916 p_oks_coverage_timezones_v_rec, -- IN
1917 x_oks_coverage_timezones_v_rec); -- OUT
1918 --- If any errors happen abort API
1919 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1920 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1921 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1922 RAISE OKC_API.G_EXCEPTION_ERROR;
1923 END IF;
1924 l_return_status := populate_new_record(l_oks_coverage_timezones_v_rec, LDefOksCoverageTimezonesVRec);
1925 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1926 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1927 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1928 RAISE OKC_API.G_EXCEPTION_ERROR;
1929 END IF;
1930 LDefOksCoverageTimezonesVRec := fill_who_columns(LDefOksCoverageTimezonesVRec);
1931 --- Validate all non-missing attributes (Item Level Validation)
1932 l_return_status := Validate_Attributes(LDefOksCoverageTimezonesVRec);
1933 --- If any errors happen abort API
1934 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1935 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1936 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1937 RAISE OKC_API.G_EXCEPTION_ERROR;
1938 END IF;
1939 l_return_status := Validate_Record(LDefOksCoverageTimezonesVRec, l_db_oks_coverage_tim44);
1940 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1941 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1942 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1943 RAISE OKC_API.G_EXCEPTION_ERROR;
1944 END IF;
1945
1946 -- Lock the Record
1947 lock_row(
1948 p_api_version => p_api_version,
1949 p_init_msg_list => p_init_msg_list,
1950 x_return_status => l_return_status,
1951 x_msg_count => x_msg_count,
1952 x_msg_data => x_msg_data,
1953 p_oks_coverage_timezones_v_rec => p_oks_coverage_timezones_v_rec);
1954 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1955 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1956 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1957 RAISE OKC_API.G_EXCEPTION_ERROR;
1958 END IF;
1959
1960 -----------------------------------------
1961 -- Move VIEW record to "Child" records --
1962 -----------------------------------------
1963 migrate(LDefOksCoverageTimezonesVRec, l_oks_coverage_timezones_rec);
1964 -----------------------------------------------
1965 -- Call the UPDATE_ROW for each child record --
1966 -----------------------------------------------
1967 update_row(
1968 p_init_msg_list,
1969 l_return_status,
1970 x_msg_count,
1971 x_msg_data,
1972 l_oks_coverage_timezones_rec,
1973 lx_oks_coverage_timezones_rec
1974 );
1975 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1976 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1977 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1978 RAISE OKC_API.G_EXCEPTION_ERROR;
1979 END IF;
1980 migrate(lx_oks_coverage_timezones_rec, LDefOksCoverageTimezonesVRec);
1981 x_oks_coverage_timezones_v_rec := LDefOksCoverageTimezonesVRec;
1982 x_return_status := l_return_status;
1983 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1984 EXCEPTION
1985 WHEN OKC_API.G_EXCEPTION_ERROR THEN
1986 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1987 (
1988 l_api_name,
1989 G_PKG_NAME,
1990 'OKC_API.G_RET_STS_ERROR',
1991 x_msg_count,
1992 x_msg_data,
1993 '_PVT'
1994 );
1995 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1996 x_return_status := OKC_API.HANDLE_EXCEPTIONS
1997 (
1998 l_api_name,
1999 G_PKG_NAME,
2000 'OKC_API.G_RET_STS_UNEXP_ERROR',
2001 x_msg_count,
2002 x_msg_data,
2003 '_PVT'
2004 );
2005 WHEN OTHERS THEN
2006 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2007 (
2008 l_api_name,
2009 G_PKG_NAME,
2010 'OTHERS',
2011 x_msg_count,
2012 x_msg_data,
2013 '_PVT'
2014 );
2015 END update_row;
2016 ------------------------------------------------------------
2017 -- PL/SQL TBL update_row for:oks_coverage_timezones_v_tbl --
2018 ------------------------------------------------------------
2019 PROCEDURE update_row(
2020 p_api_version IN NUMBER,
2021 p_init_msg_list IN VARCHAR2,
2022 x_return_status OUT NOCOPY VARCHAR2,
2023 x_msg_count OUT NOCOPY NUMBER,
2024 x_msg_data OUT NOCOPY VARCHAR2,
2025 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType,
2026 x_oks_coverage_timezones_v_tbl OUT NOCOPY OksCoverageTimezonesVTblType,
2027 px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
2028
2029 l_api_version CONSTANT NUMBER := 1;
2030 l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_update_row';
2031 i NUMBER := 0;
2032 BEGIN
2033 OKC_API.init_msg_list(p_init_msg_list);
2034 -- Make sure PL/SQL table has records in it before passing
2035 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
2036 i := p_oks_coverage_timezones_v_tbl.FIRST;
2037 LOOP
2038 DECLARE
2039 l_error_rec OKC_API.ERROR_REC_TYPE;
2040 BEGIN
2041 l_error_rec.api_name := l_api_name;
2042 l_error_rec.api_package := G_PKG_NAME;
2043 l_error_rec.idx := i;
2044 update_row (
2045 p_api_version => p_api_version,
2046 p_init_msg_list => OKC_API.G_FALSE,
2047 x_return_status => l_error_rec.error_type,
2048 x_msg_count => l_error_rec.msg_count,
2049 x_msg_data => l_error_rec.msg_data,
2050 p_oks_coverage_timezones_v_rec => p_oks_coverage_timezones_v_tbl(i),
2051 x_oks_coverage_timezones_v_rec => x_oks_coverage_timezones_v_tbl(i));
2052 IF (l_error_rec.error_type <> OKC_API.G_RET_STS_SUCCESS) THEN
2053 l_error_rec.sqlcode := SQLCODE;
2054 load_error_tbl(l_error_rec, px_error_tbl);
2055 ELSE
2056 x_msg_count := l_error_rec.msg_count;
2057 x_msg_data := l_error_rec.msg_data;
2058 END IF;
2059 EXCEPTION
2060 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2061 l_error_rec.error_type := OKC_API.G_RET_STS_ERROR;
2062 l_error_rec.sqlcode := SQLCODE;
2063 load_error_tbl(l_error_rec, px_error_tbl);
2064 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2065 l_error_rec.error_type := OKC_API.G_RET_STS_UNEXP_ERROR;
2066 l_error_rec.sqlcode := SQLCODE;
2067 load_error_tbl(l_error_rec, px_error_tbl);
2068 WHEN OTHERS THEN
2069 l_error_rec.error_type := 'OTHERS';
2070 l_error_rec.sqlcode := SQLCODE;
2071 load_error_tbl(l_error_rec, px_error_tbl);
2072 END;
2073 EXIT WHEN (i = p_oks_coverage_timezones_v_tbl.LAST);
2074 i := p_oks_coverage_timezones_v_tbl.NEXT(i);
2075 END LOOP;
2076 END IF;
2077 -- Loop through the error_tbl to find the error with the highest severity
2078 -- and return it.
2079 x_return_status := find_highest_exception(px_error_tbl);
2080 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2081 EXCEPTION
2082 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2083 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2084 (
2085 l_api_name,
2086 G_PKG_NAME,
2087 'OKC_API.G_RET_STS_ERROR',
2088 x_msg_count,
2089 x_msg_data,
2090 '_PVT'
2091 );
2092 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2093 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2094 (
2095 l_api_name,
2096 G_PKG_NAME,
2097 'OKC_API.G_RET_STS_UNEXP_ERROR',
2098 x_msg_count,
2099 x_msg_data,
2100 '_PVT'
2101 );
2102 WHEN OTHERS THEN
2103 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2104 (
2105 l_api_name,
2106 G_PKG_NAME,
2107 'OTHERS',
2108 x_msg_count,
2109 x_msg_data,
2110 '_PVT'
2111 );
2112 END update_row;
2113
2114 ------------------------------------------------------------
2115 -- PL/SQL TBL update_row for:OKS_COVERAGE_TIMEZONES_V_TBL --
2116 ------------------------------------------------------------
2117 -- This procedure is the same as the one above except it does not have a "px_error_tbl" argument.
2118 -- This procedure was create for backward compatibility and simply is a wrapper for the one above.
2119 PROCEDURE update_row(
2120 p_api_version IN NUMBER,
2121 p_init_msg_list IN VARCHAR2,
2122 x_return_status OUT NOCOPY VARCHAR2,
2123 x_msg_count OUT NOCOPY NUMBER,
2124 x_msg_data OUT NOCOPY VARCHAR2,
2125 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType,
2126 x_oks_coverage_timezones_v_tbl OUT NOCOPY OksCoverageTimezonesVTblType) IS
2127
2128 l_api_version CONSTANT NUMBER := 1;
2129 l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
2130 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2131 l_error_tbl OKC_API.ERROR_TBL_TYPE;
2132 BEGIN
2133 OKC_API.init_msg_list(p_init_msg_list);
2134 -- Make sure PL/SQL table has records in it before passing
2135 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
2136 update_row (
2137 p_api_version => p_api_version,
2138 p_init_msg_list => OKC_API.G_FALSE,
2139 x_return_status => x_return_status,
2140 x_msg_count => x_msg_count,
2141 x_msg_data => x_msg_data,
2142 p_oks_coverage_timezones_v_tbl => p_oks_coverage_timezones_v_tbl,
2143 x_oks_coverage_timezones_v_tbl => x_oks_coverage_timezones_v_tbl,
2144 px_error_tbl => l_error_tbl);
2145 END IF;
2146 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2147 EXCEPTION
2148 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2149 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2150 (
2151 l_api_name,
2152 G_PKG_NAME,
2153 'OKC_API.G_RET_STS_ERROR',
2154 x_msg_count,
2155 x_msg_data,
2156 '_PVT'
2157 );
2158 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2159 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2160 (
2161 l_api_name,
2162 G_PKG_NAME,
2163 'OKC_API.G_RET_STS_UNEXP_ERROR',
2164 x_msg_count,
2165 x_msg_data,
2166 '_PVT'
2167 );
2168 WHEN OTHERS THEN
2169 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2170 (
2171 l_api_name,
2172 G_PKG_NAME,
2173 'OTHERS',
2174 x_msg_count,
2175 x_msg_data,
2176 '_PVT'
2177 );
2178 END update_row;
2179
2180 ---------------------------------------------------------------------------
2181 -- PROCEDURE delete_row
2182 ---------------------------------------------------------------------------
2183 -------------------------------------------
2184 -- delete_row for:OKS_COVERAGE_TIMEZONES --
2185 -------------------------------------------
2186 PROCEDURE delete_row(
2187 p_init_msg_list IN VARCHAR2,
2188 x_return_status OUT NOCOPY VARCHAR2,
2189 x_msg_count OUT NOCOPY NUMBER,
2190 x_msg_data OUT NOCOPY VARCHAR2,
2191 p_oks_coverage_timezones_rec IN OksCoverageTimezonesRecType) IS
2192
2193 l_api_version CONSTANT NUMBER := 1;
2194 l_api_name CONSTANT VARCHAR2(30) := 'B_delete_row';
2195 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2196 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType := p_oks_coverage_timezones_rec;
2197 l_row_notfound BOOLEAN := TRUE;
2198 BEGIN
2199 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2200 p_init_msg_list,
2201 '_PVT',
2202 x_return_status);
2203 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2204 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2205 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2206 RAISE OKC_API.G_EXCEPTION_ERROR;
2207 END IF;
2208
2209 DELETE FROM OKS_COVERAGE_TIMEZONES
2210 WHERE ID = p_oks_coverage_timezones_rec.id;
2211
2212 x_return_status := l_return_status;
2213 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2214 EXCEPTION
2215 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2216 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2217 (
2218 l_api_name,
2219 G_PKG_NAME,
2220 'OKC_API.G_RET_STS_ERROR',
2221 x_msg_count,
2222 x_msg_data,
2223 '_PVT'
2224 );
2225 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2226 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2227 (
2228 l_api_name,
2229 G_PKG_NAME,
2230 'OKC_API.G_RET_STS_UNEXP_ERROR',
2231 x_msg_count,
2232 x_msg_data,
2233 '_PVT'
2234 );
2235 WHEN OTHERS THEN
2236 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2237 (
2238 l_api_name,
2239 G_PKG_NAME,
2240 'OTHERS',
2241 x_msg_count,
2242 x_msg_data,
2243 '_PVT'
2244 );
2245 END delete_row;
2246 ---------------------------------------------
2247 -- delete_row for:OKS_COVERAGE_TIMEZONES_V --
2248 ---------------------------------------------
2249 PROCEDURE delete_row(
2250 p_api_version IN NUMBER,
2251 p_init_msg_list IN VARCHAR2,
2252 x_return_status OUT NOCOPY VARCHAR2,
2253 x_msg_count OUT NOCOPY NUMBER,
2254 x_msg_data OUT NOCOPY VARCHAR2,
2255 p_oks_coverage_timezones_v_rec IN OksCoverageTimezonesVRecType) IS
2256
2257 l_api_version CONSTANT NUMBER := 1;
2258 l_api_name CONSTANT VARCHAR2(30) := 'V_delete_row';
2259 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2260 l_oks_coverage_timezones_v_rec OksCoverageTimezonesVRecType := p_oks_coverage_timezones_v_rec;
2261 l_oks_coverage_timezones_rec OksCoverageTimezonesRecType;
2262 BEGIN
2263 l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2264 G_PKG_NAME,
2265 p_init_msg_list,
2266 l_api_version,
2267 p_api_version,
2268 '_PVT',
2269 x_return_status);
2270 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2271 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2272 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2273 RAISE OKC_API.G_EXCEPTION_ERROR;
2274 END IF;
2275 -----------------------------------------
2276 -- Move VIEW record to "Child" records --
2277 -----------------------------------------
2278 migrate(l_oks_coverage_timezones_v_rec, l_oks_coverage_timezones_rec);
2279 -----------------------------------------------
2280 -- Call the DELETE_ROW for each child record --
2281 -----------------------------------------------
2282 delete_row(
2283 p_init_msg_list,
2284 l_return_status,
2285 x_msg_count,
2286 x_msg_data,
2287 l_oks_coverage_timezones_rec
2288 );
2289 IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2290 RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2291 ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2292 RAISE OKC_API.G_EXCEPTION_ERROR;
2293 END IF;
2294 x_return_status := l_return_status;
2295 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2296 EXCEPTION
2297 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2298 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2299 (
2300 l_api_name,
2301 G_PKG_NAME,
2302 'OKC_API.G_RET_STS_ERROR',
2303 x_msg_count,
2304 x_msg_data,
2305 '_PVT'
2306 );
2307 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2308 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2309 (
2310 l_api_name,
2311 G_PKG_NAME,
2312 'OKC_API.G_RET_STS_UNEXP_ERROR',
2313 x_msg_count,
2314 x_msg_data,
2315 '_PVT'
2316 );
2317 WHEN OTHERS THEN
2318 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2319 (
2320 l_api_name,
2321 G_PKG_NAME,
2322 'OTHERS',
2323 x_msg_count,
2324 x_msg_data,
2325 '_PVT'
2326 );
2327 END delete_row;
2328 --------------------------------------------------------
2329 -- PL/SQL TBL delete_row for:OKS_COVERAGE_TIMEZONES_V --
2330 --------------------------------------------------------
2331 PROCEDURE delete_row(
2332 p_api_version IN NUMBER,
2333 p_init_msg_list IN VARCHAR2,
2334 x_return_status OUT NOCOPY VARCHAR2,
2335 x_msg_count OUT NOCOPY NUMBER,
2336 x_msg_data OUT NOCOPY VARCHAR2,
2337 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType,
2338 px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
2339
2340 l_api_version CONSTANT NUMBER := 1;
2341 l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_delete_row';
2342 i NUMBER := 0;
2343 BEGIN
2344 OKC_API.init_msg_list(p_init_msg_list);
2345 -- Make sure PL/SQL table has records in it before passing
2346 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
2347 i := p_oks_coverage_timezones_v_tbl.FIRST;
2348 LOOP
2349 DECLARE
2350 l_error_rec OKC_API.ERROR_REC_TYPE;
2351 BEGIN
2352 l_error_rec.api_name := l_api_name;
2353 l_error_rec.api_package := G_PKG_NAME;
2354 l_error_rec.idx := i;
2355 delete_row (
2356 p_api_version => p_api_version,
2357 p_init_msg_list => OKC_API.G_FALSE,
2358 x_return_status => l_error_rec.error_type,
2359 x_msg_count => l_error_rec.msg_count,
2360 x_msg_data => l_error_rec.msg_data,
2361 p_oks_coverage_timezones_v_rec => p_oks_coverage_timezones_v_tbl(i));
2362 IF (l_error_rec.error_type <> OKC_API.G_RET_STS_SUCCESS) THEN
2363 l_error_rec.sqlcode := SQLCODE;
2364 load_error_tbl(l_error_rec, px_error_tbl);
2365 ELSE
2366 x_msg_count := l_error_rec.msg_count;
2367 x_msg_data := l_error_rec.msg_data;
2368 END IF;
2369 EXCEPTION
2370 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2371 l_error_rec.error_type := OKC_API.G_RET_STS_ERROR;
2372 l_error_rec.sqlcode := SQLCODE;
2373 load_error_tbl(l_error_rec, px_error_tbl);
2374 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2375 l_error_rec.error_type := OKC_API.G_RET_STS_UNEXP_ERROR;
2376 l_error_rec.sqlcode := SQLCODE;
2377 load_error_tbl(l_error_rec, px_error_tbl);
2378 WHEN OTHERS THEN
2379 l_error_rec.error_type := 'OTHERS';
2380 l_error_rec.sqlcode := SQLCODE;
2381 load_error_tbl(l_error_rec, px_error_tbl);
2382 END;
2383 EXIT WHEN (i = p_oks_coverage_timezones_v_tbl.LAST);
2384 i := p_oks_coverage_timezones_v_tbl.NEXT(i);
2385 END LOOP;
2386 END IF;
2387 -- Loop through the error_tbl to find the error with the highest severity
2388 -- and return it.
2389 x_return_status := find_highest_exception(px_error_tbl);
2390 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2391 EXCEPTION
2392 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2393 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2394 (
2395 l_api_name,
2396 G_PKG_NAME,
2397 'OKC_API.G_RET_STS_ERROR',
2398 x_msg_count,
2399 x_msg_data,
2400 '_PVT'
2401 );
2402 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2403 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2404 (
2405 l_api_name,
2406 G_PKG_NAME,
2407 'OKC_API.G_RET_STS_UNEXP_ERROR',
2408 x_msg_count,
2409 x_msg_data,
2410 '_PVT'
2411 );
2412 WHEN OTHERS THEN
2413 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2414 (
2415 l_api_name,
2416 G_PKG_NAME,
2417 'OTHERS',
2418 x_msg_count,
2419 x_msg_data,
2420 '_PVT'
2421 );
2422 END delete_row;
2423
2424 --------------------------------------------------------
2425 -- PL/SQL TBL delete_row for:OKS_COVERAGE_TIMEZONES_V --
2426 --------------------------------------------------------
2427 PROCEDURE delete_row(
2428 p_api_version IN NUMBER,
2429 p_init_msg_list IN VARCHAR2,
2430 x_return_status OUT NOCOPY VARCHAR2,
2431 x_msg_count OUT NOCOPY NUMBER,
2432 x_msg_data OUT NOCOPY VARCHAR2,
2433 p_oks_coverage_timezones_v_tbl IN OksCoverageTimezonesVTblType) IS
2434
2435 l_api_version CONSTANT NUMBER := 1;
2436 l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
2437 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2438 l_error_tbl OKC_API.ERROR_TBL_TYPE;
2439 BEGIN
2440 OKC_API.init_msg_list(p_init_msg_list);
2441 -- Make sure PL/SQL table has records in it before passing
2442 IF (p_oks_coverage_timezones_v_tbl.COUNT > 0) THEN
2443 delete_row (
2444 p_api_version => p_api_version,
2445 p_init_msg_list => OKC_API.G_FALSE,
2446 x_return_status => x_return_status,
2447 x_msg_count => x_msg_count,
2448 x_msg_data => x_msg_data,
2449 p_oks_coverage_timezones_v_tbl => p_oks_coverage_timezones_v_tbl,
2450 px_error_tbl => l_error_tbl);
2451 END IF;
2452 OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2453 EXCEPTION
2454 WHEN OKC_API.G_EXCEPTION_ERROR THEN
2455 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2456 (
2457 l_api_name,
2458 G_PKG_NAME,
2459 'OKC_API.G_RET_STS_ERROR',
2460 x_msg_count,
2461 x_msg_data,
2462 '_PVT'
2463 );
2464 WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2465 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2466 (
2467 l_api_name,
2468 G_PKG_NAME,
2469 'OKC_API.G_RET_STS_UNEXP_ERROR',
2470 x_msg_count,
2471 x_msg_data,
2472 '_PVT'
2473 );
2474 WHEN OTHERS THEN
2475 x_return_status := OKC_API.HANDLE_EXCEPTIONS
2476 (
2477 l_api_name,
2478 G_PKG_NAME,
2479 'OTHERS',
2480 x_msg_count,
2481 x_msg_data,
2482 '_PVT'
2483 );
2484 END delete_row;
2485
2486
2487 FUNCTION Create_Version(
2488 p_id IN NUMBER,
2489 p_major_version IN NUMBER) RETURN VARCHAR2 IS
2490
2491 l_return_status VARCHAR2(1):= OKC_API.G_RET_STS_SUCCESS;
2492 l_debug VARCHAR2(1) := NVL(FND_PROFILE.VALUE('AFLOG_ENABLED'),'N');
2493
2494 BEGIN
2495
2496 IF (l_debug = 'Y') THEN
2497 okc_debug.Set_Indentation('OKS_CTZ_PVT');
2498 okc_debug.log('23700: Entered create_version', 2);
2499 END IF;
2500
2501 INSERT INTO OKS_COVERAGE_TIMEZONES_H(
2502 ID,
2503 CLE_ID,
2504 DEFAULT_YN,
2505 TIMEZONE_ID,
2506 DNZ_CHR_ID,
2507 SECURITY_GROUP_ID,
2508 PROGRAM_APPLICATION_ID,
2509 PROGRAM_ID,
2510 PROGRAM_UPDATE_DATE,
2511 REQUEST_ID,
2512 CREATED_BY,
2513 CREATION_DATE,
2514 LAST_UPDATED_BY,
2515 LAST_UPDATE_DATE,
2516 LAST_UPDATE_LOGIN,
2517 OBJECT_VERSION_NUMBER,
2518 MAJOR_VERSION-- ,
2519 -- R12 Data Model Changes 4485150 Start
2520 /* ORIG_SYSTEM_ID1,
2521 ORIG_SYSTEM_REFERENCE1,
2522 ORIG_SYSTEM_SOURCE_CODE */
2523 -- R12 Data Model Changes 4485150 End
2524 )
2525 SELECT
2526 ID,
2527 CLE_ID,
2528 DEFAULT_YN,
2529 TIMEZONE_ID,
2530 DNZ_CHR_ID,
2531 SECURITY_GROUP_ID,
2532 PROGRAM_APPLICATION_ID,
2533 PROGRAM_ID,
2534 PROGRAM_UPDATE_DATE,
2535 REQUEST_ID,
2536 CREATED_BY,
2537 CREATION_DATE,
2538 LAST_UPDATED_BY,
2539 LAST_UPDATE_DATE,
2540 LAST_UPDATE_LOGIN,
2541 OBJECT_VERSION_NUMBER,
2542 p_major_version-- ,
2543 -- R12 Data Model Changes 4485150 Start
2544 /* ORIG_SYSTEM_ID1,
2545 ORIG_SYSTEM_REFERENCE1,
2546 ORIG_SYSTEM_SOURCE_CODE */
2547 -- R12 Data Model Changes 4485150 End
2548 FROM OKS_COVERAGE_TIMEZONES
2549 WHERE DNZ_CHR_ID = P_Id;
2550
2551 RETURN l_return_status;
2552
2553 IF (l_debug = 'Y') THEN
2554 okc_debug.log('23800: Exiting create_version', 2);
2555 END IF;
2556
2557 EXCEPTION
2558
2559
2560 WHEN OTHERS THEN
2561
2562 IF (l_debug = 'Y') THEN
2563 okc_debug.log('23900: Exiting create_version:OTHERS Exception', 2);
2564 okc_debug.Reset_Indentation;
2565 END IF;
2566
2567 OKC_API.SET_MESSAGE(p_app_name => okc_version_pvt.G_APP_NAME,
2568 p_msg_name => okc_version_pvt.G_UNEXPECTED_ERROR,
2569 p_token1 => okc_version_pvt.G_SQLCODE_TOKEN,
2570 p_token1_value => sqlcode,
2571 p_token2 => okc_version_pvt.G_SQLERRM_TOKEN,
2572 p_token2_value => sqlerrm);
2573
2574 l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2575
2576 return l_return_status;
2577 END Create_Version;
2578
2579
2580 FUNCTION Restore_Version(
2581 p_id IN NUMBER,
2582 p_major_version IN NUMBER) RETURN VARCHAR2 IS
2583
2584 l_return_status VARCHAR2(1):= OKC_API.G_RET_STS_SUCCESS;
2585 l_debug VARCHAR2(1) := NVL(FND_PROFILE.VALUE('AFLOG_ENABLED'),'N');
2586
2587 BEGIN
2588
2589 IF (l_debug = 'Y') THEN
2590 okc_debug.Set_Indentation('OKS_CTZ_PVT');
2591 okc_debug.log('24000: Exiting restore_version:OTHERS Exception', 2);
2592 END IF;
2593
2594 DELETE OKS_COVERAGE_TIMEZONES
2595 WHERE DNZ_CHR_ID = p_id;
2596
2597
2598
2599
2600
2601 INSERT INTO OKS_COVERAGE_TIMEZONES(
2602 ID,
2603 CLE_ID,
2604 DEFAULT_YN,
2605 TIMEZONE_ID,
2606 DNZ_CHR_ID,
2607 SECURITY_GROUP_ID,
2608 PROGRAM_APPLICATION_ID,
2609 PROGRAM_ID,
2610 PROGRAM_UPDATE_DATE,
2611 REQUEST_ID,
2612 CREATED_BY,
2613 CREATION_DATE,
2614 LAST_UPDATED_BY,
2615 LAST_UPDATE_DATE,
2616 LAST_UPDATE_LOGIN,
2617 OBJECT_VERSION_NUMBER--,
2618 -- R12 Data Model Changes 4485150 Start
2619 /* ORIG_SYSTEM_ID1,
2620 ORIG_SYSTEM_REFERENCE1,
2621 ORIG_SYSTEM_SOURCE_CODE */
2622 -- R12 Data Model Changes 4485150 End
2623 )
2624 SELECT
2625 ID,
2626 CLE_ID,
2627 DEFAULT_YN,
2628 TIMEZONE_ID,
2629 DNZ_CHR_ID,
2630 SECURITY_GROUP_ID,
2631 PROGRAM_APPLICATION_ID,
2632 PROGRAM_ID,
2633 PROGRAM_UPDATE_DATE,
2634 REQUEST_ID,
2635 CREATED_BY,
2636 CREATION_DATE,
2637 LAST_UPDATED_BY,
2638 LAST_UPDATE_DATE,
2639 LAST_UPDATE_LOGIN,
2640 OBJECT_VERSION_NUMBER--,
2641 -- R12 Data Model Changes 4485150 Start
2642 /* ORIG_SYSTEM_ID1,
2643 ORIG_SYSTEM_REFERENCE1,
2644 ORIG_SYSTEM_SOURCE_CODE */
2645 -- R12 Data Model Changes 4485150 End
2646 FROM OKS_COVERAGE_TIMEZONES_H
2647 WHERE DNZ_CHR_ID = P_Id
2648 AND major_version = p_major_version;
2649 RETURN l_return_status;
2650
2651 IF (l_debug = 'Y') THEN
2652 okc_debug.log('24100: Exiting restore_version:OTHERS Exception', 2);
2653 END IF;
2654
2655 EXCEPTION
2656
2657 WHEN OTHERS THEN
2658
2659 IF (l_debug = 'Y') THEN
2660
2661 okc_debug.log('24200: Exiting restore_version:OTHERS Exception', 2);
2662 okc_debug.Reset_Indentation;
2663
2664 END IF;
2665
2666 OKC_API.SET_MESSAGE(p_app_name => okc_version_pvt.G_APP_NAME,
2667 p_msg_name => okc_version_pvt.G_UNEXPECTED_ERROR,
2668 p_token1 => okc_version_pvt.G_SQLCODE_TOKEN,
2669 p_token1_value => sqlcode,
2670 p_token2 => okc_version_pvt.G_SQLERRM_TOKEN,
2671 p_token2_value => sqlerrm);
2672
2673 l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2674
2675 return l_return_status;
2676
2677 END Restore_Version;
2678
2679
2680
2681 END OKS_CTZ_PVT;