[Home] [Help]
PACKAGE BODY: APPS.OKC_OPER_INST_PUB
Source
1 PACKAGE BODY OKC_OPER_INST_PUB AS
2 /* $Header: OKCPCOPB.pls 120.0 2005/05/25 22:49:09 appldev noship $ */
3 l_debug VARCHAR2(1) := NVL(FND_PROFILE.VALUE('AFLOG_ENABLED'),'N');
4
5 g_api_type CONSTANT VARCHAR2(4) := '_PUB';
6
7 PROCEDURE Create_Class_Operation(
8 p_api_version IN NUMBER,
9 p_init_msg_list IN VARCHAR2 ,
10 x_return_status OUT NOCOPY VARCHAR2,
11 x_msg_count OUT NOCOPY NUMBER,
12 x_msg_data OUT NOCOPY VARCHAR2,
13 p_copv_rec IN copv_rec_type,
14 x_copv_rec OUT NOCOPY copv_rec_type) IS
15
16 l_copv_rec copv_rec_type;
17 l_api_name CONSTANT VARCHAR2(30) := 'Create_Class_Operation';
18 l_api_version CONSTANT NUMBER := 1.0;
19 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
20 BEGIN
21 -- call START_ACTIVITY to Create savepoint, check compatibility
22 -- and initialize message list
23 l_return_status := OKC_API.START_ACTIVITY(
24 p_api_name => l_api_name,
25 p_pkg_name => g_pkg_name,
26 p_init_msg_list => p_init_msg_list,
27 l_api_version => l_api_version,
28 p_api_version => p_api_version,
29 p_api_type => g_api_type,
30 x_return_status => x_return_status);
31
32 -- check if activity started successfully
33 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
34 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
35 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
36 raise OKC_API.G_EXCEPTION_ERROR;
37 End If;
38
39 -- call BEFORE user hook
40 l_copv_rec := p_copv_rec;
41 g_copv_rec := l_copv_rec;
42
43 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
44 p_package_name => g_pkg_name,
45 p_procedure_name => l_api_name,
46 p_before_after => 'B');
47
48 -- check return status of user hook call
49 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
50 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
51 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
52 raise OKC_API.G_EXCEPTION_ERROR;
53 End If;
54
55 -- get values back from user hook call
56 l_copv_rec := g_copv_rec;
57 l_copv_rec.id := p_copv_rec.id;
58 l_copv_rec.object_version_number := p_copv_rec.object_version_number;
59
60 -- call procedure in complex API
61 OKC_OPER_INST_PVT.Create_Class_Operation(
62 p_api_version => p_api_version,
63 p_init_msg_list => p_init_msg_list,
64 x_return_status => x_return_status,
65 x_msg_count => x_msg_count,
66 x_msg_data => x_msg_data,
67 p_copv_rec => l_copv_rec,
68 x_copv_rec => x_copv_rec);
69
70 -- check return status
71 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
72 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
73 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
74 raise OKC_API.G_EXCEPTION_ERROR;
75 End If;
76
77 -- call AFTER user hook
78 g_copv_rec := x_copv_rec;
79
80 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
81 p_package_name => g_pkg_name,
82 p_procedure_name => l_api_name,
83 p_before_after => 'A');
84
85 -- check return status of the user hook call
86 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
87 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
88 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
89 raise OKC_API.G_EXCEPTION_ERROR;
90 End If;
91
92 -- end activity
93 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
94 x_msg_data => x_msg_data);
95 EXCEPTION
96 when OKC_API.G_EXCEPTION_ERROR then
97 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
98 p_api_name => l_api_name,
99 p_pkg_name => g_pkg_name,
100 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
101 x_msg_count => x_msg_count,
102 x_msg_data => x_msg_data,
103 p_api_type => g_api_type);
104
105 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
106 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
107 p_api_name => l_api_name,
108 p_pkg_name => g_pkg_name,
109 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
110 x_msg_count => x_msg_count,
111 x_msg_data => x_msg_data,
112 p_api_type => g_api_type);
113
114 when OTHERS then
115 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
116 p_api_name => l_api_name,
117 p_pkg_name => g_pkg_name,
118 p_exc_name => 'OTHERS',
119 x_msg_count => x_msg_count,
120 x_msg_data => x_msg_data,
121 p_api_type => g_api_type);
122
123 END Create_Class_Operation;
124
125 PROCEDURE Create_Class_Operation(
126 p_api_version IN NUMBER,
127 p_init_msg_list IN VARCHAR2 ,
128 x_return_status OUT NOCOPY VARCHAR2,
129 x_msg_count OUT NOCOPY NUMBER,
130 x_msg_data OUT NOCOPY VARCHAR2,
131 p_copv_tbl IN copv_tbl_type,
132 x_copv_tbl OUT NOCOPY copv_tbl_type) IS
133
134 l_api_name CONSTANT VARCHAR2(30) := 'Create_Class_Operation';
135 l_api_version CONSTANT NUMBER := 1.0;
136 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
137 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
138 i NUMBER;
139 BEGIN
140 -- call START_ACTIVITY to Create savepoint, check compatibility
141 -- and initialize message list
142 l_return_status := OKC_API.START_ACTIVITY(
143 p_api_name => l_api_name,
144 p_pkg_name => g_pkg_name,
145 p_init_msg_list => p_init_msg_list,
146 l_api_version => l_api_version,
147 p_api_version => p_api_version,
148 p_api_type => g_api_type,
149 x_return_status => x_return_status);
150
151 -- check if activity started successfully
152 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
153 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
154 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
155 raise OKC_API.G_EXCEPTION_ERROR;
156 End If;
157
158 If (p_copv_tbl.COUNT > 0) Then
159 i := p_copv_tbl.FIRST;
160 LOOP
161 -- call procedure in public API for a record
162 OKC_OPER_INST_PUB.Create_Class_Operation(
163 p_api_version => p_api_version,
164 p_init_msg_list => p_init_msg_list,
165 x_return_status => x_return_status,
166 x_msg_count => x_msg_count,
167 x_msg_data => x_msg_data,
168 p_copv_rec => p_copv_tbl(i),
169 x_copv_rec => x_copv_tbl(i));
170
171 -- store the highest degree of error
172 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
173 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
174 l_overall_status := x_return_status;
175 End If;
176 End If;
177 EXIT WHEN (i = p_copv_tbl.LAST);
178 i := p_copv_tbl.NEXT(i);
179 END LOOP;
180 -- return overall status
181 x_return_status := l_overall_status;
182 End If;
183
184 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
185 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
186 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
187 raise OKC_API.G_EXCEPTION_ERROR;
188 End If;
189
190 -- end activity
191 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
192 x_msg_data => x_msg_data);
193 EXCEPTION
194 when OKC_API.G_EXCEPTION_ERROR then
195 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
196 p_api_name => l_api_name,
197 p_pkg_name => g_pkg_name,
198 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
199 x_msg_count => x_msg_count,
200 x_msg_data => x_msg_data,
201 p_api_type => g_api_type);
202
203 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
204 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
205 p_api_name => l_api_name,
206 p_pkg_name => g_pkg_name,
207 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
208 x_msg_count => x_msg_count,
209 x_msg_data => x_msg_data,
210 p_api_type => g_api_type);
211
212 when OTHERS then
213 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
214 p_api_name => l_api_name,
215 p_pkg_name => g_pkg_name,
216 p_exc_name => 'OTHERS',
217 x_msg_count => x_msg_count,
218 x_msg_data => x_msg_data,
219 p_api_type => g_api_type);
220
221 END Create_Class_Operation;
222
223 PROCEDURE Update_Class_Operation(
224 p_api_version IN NUMBER,
225 p_init_msg_list IN VARCHAR2 ,
226 x_return_status OUT NOCOPY VARCHAR2,
227 x_msg_count OUT NOCOPY NUMBER,
228 x_msg_data OUT NOCOPY VARCHAR2,
229 p_copv_rec IN copv_rec_type,
230 x_copv_rec OUT NOCOPY copv_rec_type) IS
231
232 l_copv_rec copv_rec_type;
233 l_api_name CONSTANT VARCHAR2(30) := 'Update_Class_Operation';
234 l_api_version CONSTANT NUMBER := 1.0;
235 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
236 BEGIN
237 -- call START_ACTIVITY to Create savepoint, check compatibility
238 -- and initialize message list
239 l_return_status := OKC_API.START_ACTIVITY(
240 p_api_name => l_api_name,
241 p_pkg_name => g_pkg_name,
242 p_init_msg_list => p_init_msg_list,
243 l_api_version => l_api_version,
244 p_api_version => p_api_version,
245 p_api_type => g_api_type,
246 x_return_status => x_return_status);
247
248 -- check if activity started successfully
249 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
250 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
251 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
252 raise OKC_API.G_EXCEPTION_ERROR;
253 End If;
254
255 -- call BEFORE user hook
256 l_copv_rec := p_copv_rec;
257 g_copv_rec := l_copv_rec;
258
259 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
260 p_package_name => g_pkg_name,
261 p_procedure_name => l_api_name,
262 p_before_after => 'B');
263
264 -- check return status of user hook call
265 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
266 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
267 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
268 raise OKC_API.G_EXCEPTION_ERROR;
269 End If;
270
271 -- get values back from user hook call
272 l_copv_rec := g_copv_rec;
273 l_copv_rec.id := p_copv_rec.id;
274 l_copv_rec.object_version_number := p_copv_rec.object_version_number;
275
276 -- call procedure in complex API
277 OKC_OPER_INST_PVT.Update_Class_Operation(
278 p_api_version => p_api_version,
279 p_init_msg_list => p_init_msg_list,
280 x_return_status => x_return_status,
281 x_msg_count => x_msg_count,
282 x_msg_data => x_msg_data,
283 p_copv_rec => l_copv_rec,
284 x_copv_rec => x_copv_rec);
285
286 -- check return status
287 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
288 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
289 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
290 raise OKC_API.G_EXCEPTION_ERROR;
291 End If;
292
293 -- call AFTER user hook
294 g_copv_rec := x_copv_rec;
295
296 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
297 p_package_name => g_pkg_name,
298 p_procedure_name => l_api_name,
299 p_before_after => 'A');
300
301 -- check return status of the user hook call
302 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
303 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
304 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
305 raise OKC_API.G_EXCEPTION_ERROR;
306 End If;
307
308 -- end activity
309 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
310 x_msg_data => x_msg_data);
311 EXCEPTION
312 when OKC_API.G_EXCEPTION_ERROR then
313 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
314 p_api_name => l_api_name,
315 p_pkg_name => g_pkg_name,
316 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
317 x_msg_count => x_msg_count,
318 x_msg_data => x_msg_data,
319 p_api_type => g_api_type);
320
321 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
322 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
323 p_api_name => l_api_name,
324 p_pkg_name => g_pkg_name,
325 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
326 x_msg_count => x_msg_count,
327 x_msg_data => x_msg_data,
328 p_api_type => g_api_type);
329
330 when OTHERS then
331 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
332 p_api_name => l_api_name,
333 p_pkg_name => g_pkg_name,
334 p_exc_name => 'OTHERS',
335 x_msg_count => x_msg_count,
336 x_msg_data => x_msg_data,
337 p_api_type => g_api_type);
338
339 END Update_Class_Operation;
340
341 PROCEDURE Update_Class_Operation(
342 p_api_version IN NUMBER,
343 p_init_msg_list IN VARCHAR2 ,
344 x_return_status OUT NOCOPY VARCHAR2,
345 x_msg_count OUT NOCOPY NUMBER,
346 x_msg_data OUT NOCOPY VARCHAR2,
347 p_copv_tbl IN copv_tbl_type,
348 x_copv_tbl OUT NOCOPY copv_tbl_type) IS
349
350 l_api_name CONSTANT VARCHAR2(30) := 'Update_Class_Operation';
351 l_api_version CONSTANT NUMBER := 1.0;
352 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
353 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
354 i NUMBER;
355 BEGIN
356 -- call START_ACTIVITY to Create savepoint, check compatibility
357 -- and initialize message list
358 l_return_status := OKC_API.START_ACTIVITY(
359 p_api_name => l_api_name,
360 p_pkg_name => g_pkg_name,
361 p_init_msg_list => p_init_msg_list,
362 l_api_version => l_api_version,
363 p_api_version => p_api_version,
364 p_api_type => g_api_type,
365 x_return_status => x_return_status);
366
367 -- check if activity started successfully
368 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
369 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
370 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
371 raise OKC_API.G_EXCEPTION_ERROR;
372 End If;
373
374 If (p_copv_tbl.COUNT > 0) Then
375 i := p_copv_tbl.FIRST;
376 LOOP
377 -- call procedure in complex API
378 OKC_OPER_INST_PUB.Update_Class_Operation(
379 p_api_version => p_api_version,
380 p_init_msg_list => p_init_msg_list,
381 x_return_status => x_return_status,
382 x_msg_count => x_msg_count,
383 x_msg_data => x_msg_data,
384 p_copv_rec => p_copv_tbl(i),
385 x_copv_rec => x_copv_tbl(i));
386
387 -- store the highest degree of error
388 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
389 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
390 l_overall_status := x_return_status;
391 End If;
392 End If;
393 EXIT WHEN (i = p_copv_tbl.LAST);
394 i := p_copv_tbl.NEXT(i);
395 END LOOP;
396 -- return overall status
397 x_return_status := l_overall_status;
398 End If;
399
400 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
401 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
402 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
403 raise OKC_API.G_EXCEPTION_ERROR;
404 End If;
405
406 -- end activity
407 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
408 x_msg_data => x_msg_data);
409 EXCEPTION
410 when OKC_API.G_EXCEPTION_ERROR then
411 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
412 p_api_name => l_api_name,
413 p_pkg_name => g_pkg_name,
414 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
415 x_msg_count => x_msg_count,
416 x_msg_data => x_msg_data,
417 p_api_type => g_api_type);
418
419 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
420 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
421 p_api_name => l_api_name,
422 p_pkg_name => g_pkg_name,
423 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
424 x_msg_count => x_msg_count,
425 x_msg_data => x_msg_data,
426 p_api_type => g_api_type);
427
428 when OTHERS then
429 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
430 p_api_name => l_api_name,
431 p_pkg_name => g_pkg_name,
432 p_exc_name => 'OTHERS',
433 x_msg_count => x_msg_count,
434 x_msg_data => x_msg_data,
435 p_api_type => g_api_type);
436
437 END Update_Class_Operation;
438
439 PROCEDURE Delete_Class_Operation(
440 p_api_version IN NUMBER,
441 p_init_msg_list IN VARCHAR2 ,
442 x_return_status OUT NOCOPY VARCHAR2,
443 x_msg_count OUT NOCOPY NUMBER,
444 x_msg_data OUT NOCOPY VARCHAR2,
445 p_copv_rec IN copv_rec_type) IS
446
447 l_copv_rec copv_rec_type;
448 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Class_Operation';
449 l_api_version CONSTANT NUMBER := 1.0;
450 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
451 BEGIN
452 -- call START_ACTIVITY to Create savepoint, check compatibility
453 -- and initialize message list
454 l_return_status := OKC_API.START_ACTIVITY(
455 p_api_name => l_api_name,
456 p_pkg_name => g_pkg_name,
457 p_init_msg_list => p_init_msg_list,
458 l_api_version => l_api_version,
459 p_api_version => p_api_version,
460 p_api_type => g_api_type,
461 x_return_status => x_return_status);
462
463 -- check if activity started successfully
464 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
465 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
467 raise OKC_API.G_EXCEPTION_ERROR;
468 End If;
469
470 -- call BEFORE user hook
471 l_copv_rec := p_copv_rec;
472 g_copv_rec := l_copv_rec;
473
474 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
475 p_package_name => g_pkg_name,
476 p_procedure_name => l_api_name,
477 p_before_after => 'B');
478
479 -- check return status of user hook call
480 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
481 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
482 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
483 raise OKC_API.G_EXCEPTION_ERROR;
484 End If;
485
486 -- get values back from user hook call
487 l_copv_rec := g_copv_rec;
488 l_copv_rec.id := p_copv_rec.id;
489 l_copv_rec.object_version_number := p_copv_rec.object_version_number;
490
491 -- call procedure in complex API
492 OKC_OPER_INST_PVT.Delete_Class_Operation(
493 p_api_version => p_api_version,
494 p_init_msg_list => p_init_msg_list,
495 x_return_status => x_return_status,
496 x_msg_count => x_msg_count,
497 x_msg_data => x_msg_data,
498 p_copv_rec => l_copv_rec);
499
500 -- check return status
501 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
502 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
504 raise OKC_API.G_EXCEPTION_ERROR;
505 End If;
506
507 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
508 p_package_name => g_pkg_name,
509 p_procedure_name => l_api_name,
510 p_before_after => 'A');
511
512 -- check return status of the user hook call
513 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
514 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
515 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
516 raise OKC_API.G_EXCEPTION_ERROR;
517 End If;
518
519 -- end activity
520 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
521 x_msg_data => x_msg_data);
522 EXCEPTION
523 when OKC_API.G_EXCEPTION_ERROR then
524 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
525 p_api_name => l_api_name,
526 p_pkg_name => g_pkg_name,
527 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
528 x_msg_count => x_msg_count,
529 x_msg_data => x_msg_data,
530 p_api_type => g_api_type);
531
532 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
533 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
534 p_api_name => l_api_name,
535 p_pkg_name => g_pkg_name,
536 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
537 x_msg_count => x_msg_count,
538 x_msg_data => x_msg_data,
539 p_api_type => g_api_type);
540
541 when OTHERS then
542 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
543 p_api_name => l_api_name,
544 p_pkg_name => g_pkg_name,
545 p_exc_name => 'OTHERS',
546 x_msg_count => x_msg_count,
547 x_msg_data => x_msg_data,
548 p_api_type => g_api_type);
549
550 END Delete_Class_Operation;
551
552 PROCEDURE Delete_Class_Operation(
553 p_api_version IN NUMBER,
554 p_init_msg_list IN VARCHAR2 ,
555 x_return_status OUT NOCOPY VARCHAR2,
556 x_msg_count OUT NOCOPY NUMBER,
557 x_msg_data OUT NOCOPY VARCHAR2,
558 p_copv_tbl IN copv_tbl_type) IS
559
560 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Class_Operation';
561 l_api_version CONSTANT NUMBER := 1.0;
562 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
563 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
564 i NUMBER;
565 BEGIN
566 -- call START_ACTIVITY to Create savepoint, check compatibility
567 -- and initialize message list
568 l_return_status := OKC_API.START_ACTIVITY(
569 p_api_name => l_api_name,
570 p_pkg_name => g_pkg_name,
571 p_init_msg_list => p_init_msg_list,
572 l_api_version => l_api_version,
573 p_api_version => p_api_version,
574 p_api_type => g_api_type,
575 x_return_status => x_return_status);
576
577 -- check if activity started successfully
578 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
579 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
580 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
581 raise OKC_API.G_EXCEPTION_ERROR;
582 End If;
583
584 If (p_copv_tbl.COUNT > 0) Then
585 i := p_copv_tbl.FIRST;
586 LOOP
587 -- call procedure in complex API
588 OKC_OPER_INST_PUB.Delete_Class_Operation(
589 p_api_version => p_api_version,
590 p_init_msg_list => p_init_msg_list,
591 x_return_status => x_return_status,
592 x_msg_count => x_msg_count,
593 x_msg_data => x_msg_data,
594 p_copv_rec => p_copv_tbl(i));
595
596 -- store the highest degree of error
597 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
598 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
599 l_overall_status := x_return_status;
600 End If;
601 End If;
602 EXIT WHEN (i = p_copv_tbl.LAST);
603 i := p_copv_tbl.NEXT(i);
604 END LOOP;
605 -- return overall status
606 x_return_status := l_overall_status;
607 End If;
608
609 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
610 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
611 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
612 raise OKC_API.G_EXCEPTION_ERROR;
613 End If;
614
615 -- end activity
616 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
617 x_msg_data => x_msg_data);
618 EXCEPTION
619 when OKC_API.G_EXCEPTION_ERROR then
620 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
621 p_api_name => l_api_name,
622 p_pkg_name => g_pkg_name,
623 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
624 x_msg_count => x_msg_count,
625 x_msg_data => x_msg_data,
626 p_api_type => g_api_type);
627
628 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
629 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
630 p_api_name => l_api_name,
631 p_pkg_name => g_pkg_name,
632 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
633 x_msg_count => x_msg_count,
634 x_msg_data => x_msg_data,
635 p_api_type => g_api_type);
636
637 when OTHERS then
638 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
639 p_api_name => l_api_name,
640 p_pkg_name => g_pkg_name,
641 p_exc_name => 'OTHERS',
642 x_msg_count => x_msg_count,
643 x_msg_data => x_msg_data,
644 p_api_type => g_api_type);
645
646 END Delete_Class_Operation;
647
648 PROCEDURE Lock_Class_Operation(
649 p_api_version IN NUMBER,
650 p_init_msg_list IN VARCHAR2 ,
651 x_return_status OUT NOCOPY VARCHAR2,
652 x_msg_count OUT NOCOPY NUMBER,
653 x_msg_data OUT NOCOPY VARCHAR2,
654 p_copv_rec IN copv_rec_type) IS
655
656 l_copv_rec copv_rec_type;
657 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Class_Operation';
658 l_api_version CONSTANT NUMBER := 1.0;
659 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
660 BEGIN
661 -- call START_ACTIVITY to Create savepoint, check compatibility
662 -- and initialize message list
663 l_return_status := OKC_API.START_ACTIVITY(
664 p_api_name => l_api_name,
665 p_pkg_name => g_pkg_name,
666 p_init_msg_list => p_init_msg_list,
667 l_api_version => l_api_version,
668 p_api_version => p_api_version,
669 p_api_type => g_api_type,
670 x_return_status => x_return_status);
671
672 -- check if activity started successfully
673 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
674 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
675 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
676 raise OKC_API.G_EXCEPTION_ERROR;
677 End If;
678
679 -- call BEFORE user hook
680 l_copv_rec := p_copv_rec;
681 g_copv_rec := l_copv_rec;
682
683 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
684 p_package_name => g_pkg_name,
685 p_procedure_name => l_api_name,
686 p_before_after => 'B');
687
688 -- check return status of user hook call
689 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
690 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
691 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
692 raise OKC_API.G_EXCEPTION_ERROR;
693 End If;
694
695 -- get values back from user hook call
696 l_copv_rec := g_copv_rec;
697 l_copv_rec.id := p_copv_rec.id;
698 l_copv_rec.object_version_number := p_copv_rec.object_version_number;
699
700 -- call procedure in complex API
701 OKC_OPER_INST_PVT.Lock_Class_Operation(
702 p_api_version => p_api_version,
703 p_init_msg_list => p_init_msg_list,
704 x_return_status => x_return_status,
705 x_msg_count => x_msg_count,
706 x_msg_data => x_msg_data,
707 p_copv_rec => l_copv_rec);
708
709 -- check return status
710 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
711 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
712 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
713 raise OKC_API.G_EXCEPTION_ERROR;
714 End If;
715
716 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
717 p_package_name => g_pkg_name,
718 p_procedure_name => l_api_name,
719 p_before_after => 'A');
720
721 -- check return status of the user hook call
722 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
723 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
724 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
725 raise OKC_API.G_EXCEPTION_ERROR;
726 End If;
727
728 -- end activity
729 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
730 x_msg_data => x_msg_data);
731 EXCEPTION
732 when OKC_API.G_EXCEPTION_ERROR then
733 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
734 p_api_name => l_api_name,
735 p_pkg_name => g_pkg_name,
736 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
737 x_msg_count => x_msg_count,
738 x_msg_data => x_msg_data,
739 p_api_type => g_api_type);
740
741 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
742 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
743 p_api_name => l_api_name,
744 p_pkg_name => g_pkg_name,
745 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
746 x_msg_count => x_msg_count,
747 x_msg_data => x_msg_data,
748 p_api_type => g_api_type);
749
750 when OTHERS then
751 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
752 p_api_name => l_api_name,
753 p_pkg_name => g_pkg_name,
754 p_exc_name => 'OTHERS',
755 x_msg_count => x_msg_count,
756 x_msg_data => x_msg_data,
757 p_api_type => g_api_type);
758
759 END Lock_Class_Operation;
760
761 PROCEDURE Lock_Class_Operation(
762 p_api_version IN NUMBER,
763 p_init_msg_list IN VARCHAR2 ,
764 x_return_status OUT NOCOPY VARCHAR2,
765 x_msg_count OUT NOCOPY NUMBER,
766 x_msg_data OUT NOCOPY VARCHAR2,
767 p_copv_tbl IN copv_tbl_type) IS
768
769 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Class_Operation';
770 l_api_version CONSTANT NUMBER := 1.0;
771 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
772 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
773 i NUMBER;
774 BEGIN
775 -- call START_ACTIVITY to Create savepoint, check compatibility
776 -- and initialize message list
777 l_return_status := OKC_API.START_ACTIVITY(
778 p_api_name => l_api_name,
779 p_pkg_name => g_pkg_name,
780 p_init_msg_list => p_init_msg_list,
781 l_api_version => l_api_version,
782 p_api_version => p_api_version,
783 p_api_type => g_api_type,
784 x_return_status => x_return_status);
785
786 -- check if activity started successfully
787 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
788 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
789 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
790 raise OKC_API.G_EXCEPTION_ERROR;
791 End If;
792
793 If (p_copv_tbl.COUNT > 0) Then
794 i := p_copv_tbl.FIRST;
795 LOOP
796 -- call procedure in complex API
797 OKC_OPER_INST_PUB.Lock_Class_Operation(
798 p_api_version => p_api_version,
799 p_init_msg_list => p_init_msg_list,
800 x_return_status => x_return_status,
801 x_msg_count => x_msg_count,
802 x_msg_data => x_msg_data,
803 p_copv_rec => p_copv_tbl(i));
804
805 -- store the highest degree of error
806 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
807 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
808 l_overall_status := x_return_status;
809 End If;
810 End If;
811 EXIT WHEN (i = p_copv_tbl.LAST);
812 i := p_copv_tbl.NEXT(i);
813 END LOOP;
814 -- return overall status
815 x_return_status := l_overall_status;
816 End If;
817
818 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
819 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
820 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
821 raise OKC_API.G_EXCEPTION_ERROR;
822 End If;
823
824 -- end activity
825 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
826 x_msg_data => x_msg_data);
827 EXCEPTION
828 when OKC_API.G_EXCEPTION_ERROR then
829 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
830 p_api_name => l_api_name,
831 p_pkg_name => g_pkg_name,
832 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
833 x_msg_count => x_msg_count,
834 x_msg_data => x_msg_data,
835 p_api_type => g_api_type);
836
837 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
838 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
839 p_api_name => l_api_name,
840 p_pkg_name => g_pkg_name,
841 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
842 x_msg_count => x_msg_count,
843 x_msg_data => x_msg_data,
844 p_api_type => g_api_type);
845
846 when OTHERS then
847 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
848 p_api_name => l_api_name,
849 p_pkg_name => g_pkg_name,
850 p_exc_name => 'OTHERS',
851 x_msg_count => x_msg_count,
852 x_msg_data => x_msg_data,
853 p_api_type => g_api_type);
854
855 END Lock_Class_Operation;
856
857 PROCEDURE Validate_Class_Operation(
858 p_api_version IN NUMBER,
859 p_init_msg_list IN VARCHAR2 ,
860 x_return_status OUT NOCOPY VARCHAR2,
861 x_msg_count OUT NOCOPY NUMBER,
862 x_msg_data OUT NOCOPY VARCHAR2,
863 p_copv_rec IN copv_rec_type) IS
864
865 l_copv_rec copv_rec_type;
866 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Class_Operation';
867 l_api_version CONSTANT NUMBER := 1.0;
868 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
869 BEGIN
870 -- call START_ACTIVITY to Create savepoint, check compatibility
871 -- and initialize message list
872 l_return_status := OKC_API.START_ACTIVITY(
873 p_api_name => l_api_name,
874 p_pkg_name => g_pkg_name,
875 p_init_msg_list => p_init_msg_list,
876 l_api_version => l_api_version,
877 p_api_version => p_api_version,
878 p_api_type => g_api_type,
879 x_return_status => x_return_status);
880
881 -- check if activity started successfully
882 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
883 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
884 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
885 raise OKC_API.G_EXCEPTION_ERROR;
886 End If;
887
888 -- call BEFORE user hook
889 l_copv_rec := p_copv_rec;
890 g_copv_rec := l_copv_rec;
891
892 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
893 p_package_name => g_pkg_name,
894 p_procedure_name => l_api_name,
895 p_before_after => 'B');
896
897 -- check return status of user hook call
898 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
899 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
900 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
901 raise OKC_API.G_EXCEPTION_ERROR;
902 End If;
903
904 -- get values back from user hook call
905 l_copv_rec := g_copv_rec;
906 l_copv_rec.id := p_copv_rec.id;
907 l_copv_rec.object_version_number := p_copv_rec.object_version_number;
908
909 -- call procedure in complex API
910 OKC_OPER_INST_PVT.Validate_Class_Operation(
911 p_api_version => p_api_version,
912 p_init_msg_list => p_init_msg_list,
913 x_return_status => x_return_status,
914 x_msg_count => x_msg_count,
915 x_msg_data => x_msg_data,
916 p_copv_rec => l_copv_rec);
917
918 -- check return status
919 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
920 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
921 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
922 raise OKC_API.G_EXCEPTION_ERROR;
923 End If;
924
925 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
926 p_package_name => g_pkg_name,
927 p_procedure_name => l_api_name,
928 p_before_after => 'A');
929
930 -- check return status of the user hook call
931 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
932 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
933 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
934 raise OKC_API.G_EXCEPTION_ERROR;
935 End If;
936
937 -- end activity
938 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
939 x_msg_data => x_msg_data);
940 EXCEPTION
941 when OKC_API.G_EXCEPTION_ERROR then
942 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
943 p_api_name => l_api_name,
944 p_pkg_name => g_pkg_name,
945 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
946 x_msg_count => x_msg_count,
947 x_msg_data => x_msg_data,
948 p_api_type => g_api_type);
949
950 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
951 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
952 p_api_name => l_api_name,
953 p_pkg_name => g_pkg_name,
954 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
955 x_msg_count => x_msg_count,
956 x_msg_data => x_msg_data,
957 p_api_type => g_api_type);
958
959 when OTHERS then
960 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
961 p_api_name => l_api_name,
962 p_pkg_name => g_pkg_name,
963 p_exc_name => 'OTHERS',
964 x_msg_count => x_msg_count,
965 x_msg_data => x_msg_data,
966 p_api_type => g_api_type);
967
968 END Validate_Class_Operation;
969
970 PROCEDURE Validate_Class_Operation(
971 p_api_version IN NUMBER,
972 p_init_msg_list IN VARCHAR2 ,
973 x_return_status OUT NOCOPY VARCHAR2,
974 x_msg_count OUT NOCOPY NUMBER,
975 x_msg_data OUT NOCOPY VARCHAR2,
976 p_copv_tbl IN copv_tbl_type) IS
977
978 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Class_Operation';
979 l_api_version CONSTANT NUMBER := 1.0;
980 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
981 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
982 i NUMBER;
983 BEGIN
984 -- call START_ACTIVITY to Create savepoint, check compatibility
985 -- and initialize message list
986 l_return_status := OKC_API.START_ACTIVITY(
987 p_api_name => l_api_name,
988 p_pkg_name => g_pkg_name,
989 p_init_msg_list => p_init_msg_list,
990 l_api_version => l_api_version,
991 p_api_version => p_api_version,
992 p_api_type => g_api_type,
993 x_return_status => x_return_status);
994
995 -- check if activity started successfully
996 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
997 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
998 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
999 raise OKC_API.G_EXCEPTION_ERROR;
1000 End If;
1001
1002 If (p_copv_tbl.COUNT > 0) Then
1003 i := p_copv_tbl.FIRST;
1004 LOOP
1005 -- call procedure in complex API
1006 OKC_OPER_INST_PUB.Validate_Class_Operation(
1007 p_api_version => p_api_version,
1008 p_init_msg_list => p_init_msg_list,
1009 x_return_status => x_return_status,
1010 x_msg_count => x_msg_count,
1011 x_msg_data => x_msg_data,
1012 p_copv_rec => p_copv_tbl(i));
1013
1014 -- store the highest degree of error
1015 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1016 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1017 l_overall_status := x_return_status;
1018 End If;
1019 End If;
1020 EXIT WHEN (i = p_copv_tbl.LAST);
1021 i := p_copv_tbl.NEXT(i);
1022 END LOOP;
1023 -- return overall status
1024 x_return_status := l_overall_status;
1025 End If;
1026
1027 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1028 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1030 raise OKC_API.G_EXCEPTION_ERROR;
1031 End If;
1032
1033 -- end activity
1034 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1035 x_msg_data => x_msg_data);
1036 EXCEPTION
1037 when OKC_API.G_EXCEPTION_ERROR then
1038 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1039 p_api_name => l_api_name,
1040 p_pkg_name => g_pkg_name,
1041 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1042 x_msg_count => x_msg_count,
1043 x_msg_data => x_msg_data,
1044 p_api_type => g_api_type);
1045
1046 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1047 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1048 p_api_name => l_api_name,
1049 p_pkg_name => g_pkg_name,
1050 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1051 x_msg_count => x_msg_count,
1052 x_msg_data => x_msg_data,
1053 p_api_type => g_api_type);
1054
1055 when OTHERS then
1056 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1057 p_api_name => l_api_name,
1058 p_pkg_name => g_pkg_name,
1059 p_exc_name => 'OTHERS',
1060 x_msg_count => x_msg_count,
1061 x_msg_data => x_msg_data,
1062 p_api_type => g_api_type);
1063
1064 END Validate_Class_Operation;
1065
1066 PROCEDURE Create_Operation_Instance(
1067 p_api_version IN NUMBER,
1068 p_init_msg_list IN VARCHAR2 ,
1069 x_return_status OUT NOCOPY VARCHAR2,
1070 x_msg_count OUT NOCOPY NUMBER,
1071 x_msg_data OUT NOCOPY VARCHAR2,
1072 p_oiev_rec IN oiev_rec_type,
1073 x_oiev_rec OUT NOCOPY oiev_rec_type) IS
1074
1075 l_oiev_rec oiev_rec_type;
1076 l_api_name CONSTANT VARCHAR2(30) := 'Create_Operation_Instance';
1077 l_api_version CONSTANT NUMBER := 1.0;
1078 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1079 BEGIN
1080 -- call START_ACTIVITY to Create savepoint, check compatibility
1081 -- and initialize message list
1082 l_return_status := OKC_API.START_ACTIVITY(
1083 p_api_name => l_api_name,
1084 p_pkg_name => g_pkg_name,
1085 p_init_msg_list => p_init_msg_list,
1086 l_api_version => l_api_version,
1087 p_api_version => p_api_version,
1088 p_api_type => g_api_type,
1089 x_return_status => x_return_status);
1090
1091 -- check if activity started successfully
1092 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1093 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1094 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1095 raise OKC_API.G_EXCEPTION_ERROR;
1096 End If;
1097
1098 -- call BEFORE user hook
1099 l_oiev_rec := p_oiev_rec;
1100 g_oiev_rec := l_oiev_rec;
1101
1102 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1103 p_package_name => g_pkg_name,
1104 p_procedure_name => l_api_name,
1105 p_before_after => 'B');
1106
1107 -- check return status of user hook call
1108 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1109 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1110 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1111 raise OKC_API.G_EXCEPTION_ERROR;
1112 End If;
1113
1114 -- get values back from user hook call
1115 l_oiev_rec := g_oiev_rec;
1116 l_oiev_rec.id := p_oiev_rec.id;
1117 l_oiev_rec.object_version_number := p_oiev_rec.object_version_number;
1118
1119 -- call procedure in complex API
1120 OKC_OPER_INST_PVT.Create_Operation_Instance(
1121 p_api_version => p_api_version,
1122 p_init_msg_list => p_init_msg_list,
1123 x_return_status => x_return_status,
1124 x_msg_count => x_msg_count,
1125 x_msg_data => x_msg_data,
1126 p_oiev_rec => l_oiev_rec,
1127 x_oiev_rec => x_oiev_rec);
1128
1129 -- check return status
1130 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1131 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1132 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1133 raise OKC_API.G_EXCEPTION_ERROR;
1134 End If;
1135
1136 -- call AFTER user hook
1137 g_oiev_rec := x_oiev_rec;
1138
1139 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1140 p_package_name => g_pkg_name,
1141 p_procedure_name => l_api_name,
1142 p_before_after => 'A');
1143
1144 -- check return status of the user hook call
1145 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1146 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1147 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1148 raise OKC_API.G_EXCEPTION_ERROR;
1149 End If;
1150
1151 -- end activity
1152 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1153 x_msg_data => x_msg_data);
1154 EXCEPTION
1155 when OKC_API.G_EXCEPTION_ERROR then
1156 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1157 p_api_name => l_api_name,
1158 p_pkg_name => g_pkg_name,
1159 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1160 x_msg_count => x_msg_count,
1161 x_msg_data => x_msg_data,
1162 p_api_type => g_api_type);
1163
1164 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1165 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1166 p_api_name => l_api_name,
1167 p_pkg_name => g_pkg_name,
1168 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1169 x_msg_count => x_msg_count,
1170 x_msg_data => x_msg_data,
1171 p_api_type => g_api_type);
1172
1173 when OTHERS then
1174 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1175 p_api_name => l_api_name,
1176 p_pkg_name => g_pkg_name,
1177 p_exc_name => 'OTHERS',
1178 x_msg_count => x_msg_count,
1179 x_msg_data => x_msg_data,
1180 p_api_type => g_api_type);
1181
1182 END Create_Operation_Instance;
1183
1184 PROCEDURE Create_Operation_Instance(
1185 p_api_version IN NUMBER,
1186 p_init_msg_list IN VARCHAR2 ,
1187 x_return_status OUT NOCOPY VARCHAR2,
1188 x_msg_count OUT NOCOPY NUMBER,
1189 x_msg_data OUT NOCOPY VARCHAR2,
1190 p_oiev_tbl IN oiev_tbl_type,
1191 x_oiev_tbl OUT NOCOPY oiev_tbl_type) IS
1192
1193 l_api_name CONSTANT VARCHAR2(30) := 'Create_Operation_Instance';
1194 l_api_version CONSTANT NUMBER := 1.0;
1195 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1196 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1197 i NUMBER;
1198 BEGIN
1199 -- call START_ACTIVITY to Create savepoint, check compatibility
1200 -- and initialize message list
1201 l_return_status := OKC_API.START_ACTIVITY(
1202 p_api_name => l_api_name,
1203 p_pkg_name => g_pkg_name,
1204 p_init_msg_list => p_init_msg_list,
1205 l_api_version => l_api_version,
1206 p_api_version => p_api_version,
1207 p_api_type => g_api_type,
1208 x_return_status => x_return_status);
1209
1210 -- check if activity started successfully
1211 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1212 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1213 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1214 raise OKC_API.G_EXCEPTION_ERROR;
1215 End If;
1216
1217 If (p_oiev_tbl.COUNT > 0) Then
1218 i := p_oiev_tbl.FIRST;
1219 LOOP
1220 -- call procedure in public API for a record
1221 OKC_OPER_INST_PUB.Create_Operation_Instance(
1222 p_api_version => p_api_version,
1223 p_init_msg_list => p_init_msg_list,
1224 x_return_status => x_return_status,
1225 x_msg_count => x_msg_count,
1226 x_msg_data => x_msg_data,
1227 p_oiev_rec => p_oiev_tbl(i),
1228 x_oiev_rec => x_oiev_tbl(i));
1229
1230 -- store the highest degree of error
1231 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1232 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1233 l_overall_status := x_return_status;
1234 End If;
1235 End If;
1236 EXIT WHEN (i = p_oiev_tbl.LAST);
1237 i := p_oiev_tbl.NEXT(i);
1238 END LOOP;
1239 -- return overall status
1240 x_return_status := l_overall_status;
1241 End If;
1242
1243 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1244 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1245 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1246 raise OKC_API.G_EXCEPTION_ERROR;
1247 End If;
1248
1249 -- end activity
1250 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1251 x_msg_data => x_msg_data);
1252 EXCEPTION
1253 when OKC_API.G_EXCEPTION_ERROR then
1254 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1255 p_api_name => l_api_name,
1256 p_pkg_name => g_pkg_name,
1257 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1258 x_msg_count => x_msg_count,
1259 x_msg_data => x_msg_data,
1260 p_api_type => g_api_type);
1261
1262 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1263 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1264 p_api_name => l_api_name,
1265 p_pkg_name => g_pkg_name,
1266 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1267 x_msg_count => x_msg_count,
1268 x_msg_data => x_msg_data,
1269 p_api_type => g_api_type);
1270
1271 when OTHERS then
1272 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1273 p_api_name => l_api_name,
1274 p_pkg_name => g_pkg_name,
1275 p_exc_name => 'OTHERS',
1276 x_msg_count => x_msg_count,
1277 x_msg_data => x_msg_data,
1278 p_api_type => g_api_type);
1279
1280 END Create_Operation_Instance;
1281
1282 PROCEDURE Update_Operation_Instance(
1283 p_api_version IN NUMBER,
1284 p_init_msg_list IN VARCHAR2 ,
1285 x_return_status OUT NOCOPY VARCHAR2,
1286 x_msg_count OUT NOCOPY NUMBER,
1287 x_msg_data OUT NOCOPY VARCHAR2,
1288 p_oiev_rec IN oiev_rec_type,
1289 x_oiev_rec OUT NOCOPY oiev_rec_type) IS
1290
1291 l_oiev_rec oiev_rec_type;
1292 l_api_name CONSTANT VARCHAR2(30) := 'Update_Operation_Instance';
1293 l_api_version CONSTANT NUMBER := 1.0;
1294 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1295 BEGIN
1296 -- call START_ACTIVITY to Create savepoint, check compatibility
1297 -- and initialize message list
1298 l_return_status := OKC_API.START_ACTIVITY(
1299 p_api_name => l_api_name,
1300 p_pkg_name => g_pkg_name,
1301 p_init_msg_list => p_init_msg_list,
1302 l_api_version => l_api_version,
1303 p_api_version => p_api_version,
1304 p_api_type => g_api_type,
1305 x_return_status => x_return_status);
1306
1307 -- check if activity started successfully
1308 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1309 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1310 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1311 raise OKC_API.G_EXCEPTION_ERROR;
1312 End If;
1313
1314 -- call BEFORE user hook
1315 l_oiev_rec := p_oiev_rec;
1316 g_oiev_rec := l_oiev_rec;
1317
1318 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1319 p_package_name => g_pkg_name,
1320 p_procedure_name => l_api_name,
1321 p_before_after => 'B');
1322
1323 -- check return status of user hook call
1324 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1325 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1326 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1327 raise OKC_API.G_EXCEPTION_ERROR;
1328 End If;
1329
1330 -- get values back from user hook call
1331 l_oiev_rec := g_oiev_rec;
1332 l_oiev_rec.id := p_oiev_rec.id;
1333 l_oiev_rec.object_version_number := p_oiev_rec.object_version_number;
1334
1335 -- call procedure in complex API
1336 OKC_OPER_INST_PVT.Update_Operation_Instance(
1337 p_api_version => p_api_version,
1338 p_init_msg_list => p_init_msg_list,
1339 x_return_status => x_return_status,
1340 x_msg_count => x_msg_count,
1341 x_msg_data => x_msg_data,
1342 p_oiev_rec => l_oiev_rec,
1343 x_oiev_rec => x_oiev_rec);
1344
1345 -- check return status
1346 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1347 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1348 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1349 raise OKC_API.G_EXCEPTION_ERROR;
1350 End If;
1351
1352 -- call AFTER user hook
1353 g_oiev_rec := x_oiev_rec;
1354
1355 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1356 p_package_name => g_pkg_name,
1357 p_procedure_name => l_api_name,
1358 p_before_after => 'A');
1359
1360 -- check return status of the user hook call
1361 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1362 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1364 raise OKC_API.G_EXCEPTION_ERROR;
1365 End If;
1366
1367 -- end activity
1368 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1369 x_msg_data => x_msg_data);
1370 EXCEPTION
1371 when OKC_API.G_EXCEPTION_ERROR then
1372 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1373 p_api_name => l_api_name,
1374 p_pkg_name => g_pkg_name,
1375 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1376 x_msg_count => x_msg_count,
1377 x_msg_data => x_msg_data,
1378 p_api_type => g_api_type);
1379
1380 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1381 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1382 p_api_name => l_api_name,
1383 p_pkg_name => g_pkg_name,
1384 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1385 x_msg_count => x_msg_count,
1386 x_msg_data => x_msg_data,
1387 p_api_type => g_api_type);
1388
1389 when OTHERS then
1390 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1391 p_api_name => l_api_name,
1392 p_pkg_name => g_pkg_name,
1393 p_exc_name => 'OTHERS',
1394 x_msg_count => x_msg_count,
1395 x_msg_data => x_msg_data,
1396 p_api_type => g_api_type);
1397
1398 END Update_Operation_Instance;
1399
1400 PROCEDURE Update_Operation_Instance(
1401 p_api_version IN NUMBER,
1402 p_init_msg_list IN VARCHAR2 ,
1403 x_return_status OUT NOCOPY VARCHAR2,
1404 x_msg_count OUT NOCOPY NUMBER,
1405 x_msg_data OUT NOCOPY VARCHAR2,
1406 p_oiev_tbl IN oiev_tbl_type,
1407 x_oiev_tbl OUT NOCOPY oiev_tbl_type) IS
1408
1409 l_api_name CONSTANT VARCHAR2(30) := 'Update_Operation_Instance';
1410 l_api_version CONSTANT NUMBER := 1.0;
1411 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1412 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1413 i NUMBER;
1414 BEGIN
1415 -- call START_ACTIVITY to Create savepoint, check compatibility
1416 -- and initialize message list
1417 l_return_status := OKC_API.START_ACTIVITY(
1418 p_api_name => l_api_name,
1419 p_pkg_name => g_pkg_name,
1420 p_init_msg_list => p_init_msg_list,
1421 l_api_version => l_api_version,
1422 p_api_version => p_api_version,
1423 p_api_type => g_api_type,
1424 x_return_status => x_return_status);
1425
1426 -- check if activity started successfully
1427 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1428 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1429 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1430 raise OKC_API.G_EXCEPTION_ERROR;
1431 End If;
1432
1433 If (p_oiev_tbl.COUNT > 0) Then
1434 i := p_oiev_tbl.FIRST;
1435 LOOP
1436 -- call procedure in complex API
1437 OKC_OPER_INST_PUB.Update_Operation_Instance(
1438 p_api_version => p_api_version,
1439 p_init_msg_list => p_init_msg_list,
1440 x_return_status => x_return_status,
1441 x_msg_count => x_msg_count,
1442 x_msg_data => x_msg_data,
1443 p_oiev_rec => p_oiev_tbl(i),
1444 x_oiev_rec => x_oiev_tbl(i));
1445
1446 -- store the highest degree of error
1447 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1448 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1449 l_overall_status := x_return_status;
1450 End If;
1451 End If;
1452 EXIT WHEN (i = p_oiev_tbl.LAST);
1453 i := p_oiev_tbl.NEXT(i);
1454 END LOOP;
1455 -- return overall status
1456 x_return_status := l_overall_status;
1457 End If;
1458
1459 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1460 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1461 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1462 raise OKC_API.G_EXCEPTION_ERROR;
1463 End If;
1464
1465 -- end activity
1466 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1467 x_msg_data => x_msg_data);
1468 EXCEPTION
1469 when OKC_API.G_EXCEPTION_ERROR then
1470 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1471 p_api_name => l_api_name,
1472 p_pkg_name => g_pkg_name,
1473 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1474 x_msg_count => x_msg_count,
1475 x_msg_data => x_msg_data,
1476 p_api_type => g_api_type);
1477
1478 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1479 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1480 p_api_name => l_api_name,
1481 p_pkg_name => g_pkg_name,
1482 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1483 x_msg_count => x_msg_count,
1484 x_msg_data => x_msg_data,
1485 p_api_type => g_api_type);
1486
1487 when OTHERS then
1488 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1489 p_api_name => l_api_name,
1490 p_pkg_name => g_pkg_name,
1491 p_exc_name => 'OTHERS',
1492 x_msg_count => x_msg_count,
1493 x_msg_data => x_msg_data,
1494 p_api_type => g_api_type);
1495
1496 END Update_Operation_Instance;
1497
1498 PROCEDURE Delete_Operation_Instance(
1499 p_api_version IN NUMBER,
1500 p_init_msg_list IN VARCHAR2 ,
1501 x_return_status OUT NOCOPY VARCHAR2,
1502 x_msg_count OUT NOCOPY NUMBER,
1503 x_msg_data OUT NOCOPY VARCHAR2,
1504 p_oiev_rec IN oiev_rec_type) IS
1505
1506 l_oiev_rec oiev_rec_type;
1507 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Operation_Instance';
1508 l_api_version CONSTANT NUMBER := 1.0;
1509 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1510 BEGIN
1511 -- call START_ACTIVITY to Create savepoint, check compatibility
1512 -- and initialize message list
1513 l_return_status := OKC_API.START_ACTIVITY(
1514 p_api_name => l_api_name,
1515 p_pkg_name => g_pkg_name,
1516 p_init_msg_list => p_init_msg_list,
1517 l_api_version => l_api_version,
1518 p_api_version => p_api_version,
1519 p_api_type => g_api_type,
1520 x_return_status => x_return_status);
1521
1522 -- check if activity started successfully
1523 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1524 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1525 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1526 raise OKC_API.G_EXCEPTION_ERROR;
1527 End If;
1528
1529 -- call BEFORE user hook
1530 l_oiev_rec := p_oiev_rec;
1531 g_oiev_rec := l_oiev_rec;
1532
1533 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1534 p_package_name => g_pkg_name,
1535 p_procedure_name => l_api_name,
1536 p_before_after => 'B');
1537
1538 -- check return status of user hook call
1539 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1540 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1541 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1542 raise OKC_API.G_EXCEPTION_ERROR;
1543 End If;
1544
1545 -- get values back from user hook call
1546 l_oiev_rec := g_oiev_rec;
1547 l_oiev_rec.id := p_oiev_rec.id;
1548 l_oiev_rec.object_version_number := p_oiev_rec.object_version_number;
1549
1550 -- call procedure in complex API
1551 OKC_OPER_INST_PVT.Delete_Operation_Instance(
1552 p_api_version => p_api_version,
1553 p_init_msg_list => p_init_msg_list,
1554 x_return_status => x_return_status,
1555 x_msg_count => x_msg_count,
1556 x_msg_data => x_msg_data,
1557 p_oiev_rec => l_oiev_rec);
1558
1559 -- check return status
1560 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1561 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1562 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1563 raise OKC_API.G_EXCEPTION_ERROR;
1564 End If;
1565
1566 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1567 p_package_name => g_pkg_name,
1568 p_procedure_name => l_api_name,
1569 p_before_after => 'A');
1570
1571 -- check return status of the user hook call
1572 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1573 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1574 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1575 raise OKC_API.G_EXCEPTION_ERROR;
1576 End If;
1577
1578 -- end activity
1579 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1580 x_msg_data => x_msg_data);
1581 EXCEPTION
1582 when OKC_API.G_EXCEPTION_ERROR then
1583 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1584 p_api_name => l_api_name,
1585 p_pkg_name => g_pkg_name,
1586 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1587 x_msg_count => x_msg_count,
1588 x_msg_data => x_msg_data,
1589 p_api_type => g_api_type);
1590
1591 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1592 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1593 p_api_name => l_api_name,
1594 p_pkg_name => g_pkg_name,
1595 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1596 x_msg_count => x_msg_count,
1597 x_msg_data => x_msg_data,
1598 p_api_type => g_api_type);
1599
1600 when OTHERS then
1601 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1602 p_api_name => l_api_name,
1603 p_pkg_name => g_pkg_name,
1604 p_exc_name => 'OTHERS',
1605 x_msg_count => x_msg_count,
1606 x_msg_data => x_msg_data,
1607 p_api_type => g_api_type);
1608
1609 END Delete_Operation_Instance;
1610
1611 PROCEDURE Delete_Operation_Instance(
1612 p_api_version IN NUMBER,
1613 p_init_msg_list IN VARCHAR2 ,
1614 x_return_status OUT NOCOPY VARCHAR2,
1615 x_msg_count OUT NOCOPY NUMBER,
1616 x_msg_data OUT NOCOPY VARCHAR2,
1617 p_oiev_tbl IN oiev_tbl_type) IS
1618
1619 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Operation_Instance';
1620 l_api_version CONSTANT NUMBER := 1.0;
1621 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1622 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1623 i NUMBER;
1624 BEGIN
1625 -- call START_ACTIVITY to Create savepoint, check compatibility
1626 -- and initialize message list
1627 l_return_status := OKC_API.START_ACTIVITY(
1628 p_api_name => l_api_name,
1629 p_pkg_name => g_pkg_name,
1630 p_init_msg_list => p_init_msg_list,
1631 l_api_version => l_api_version,
1632 p_api_version => p_api_version,
1633 p_api_type => g_api_type,
1634 x_return_status => x_return_status);
1635
1636 -- check if activity started successfully
1637 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1638 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1639 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1640 raise OKC_API.G_EXCEPTION_ERROR;
1641 End If;
1642
1643 If (p_oiev_tbl.COUNT > 0) Then
1644 i := p_oiev_tbl.FIRST;
1645 LOOP
1646 -- call procedure in complex API
1647 OKC_OPER_INST_PUB.Delete_Operation_Instance(
1648 p_api_version => p_api_version,
1649 p_init_msg_list => p_init_msg_list,
1650 x_return_status => x_return_status,
1651 x_msg_count => x_msg_count,
1652 x_msg_data => x_msg_data,
1653 p_oiev_rec => p_oiev_tbl(i));
1654
1655 -- store the highest degree of error
1656 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1657 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1658 l_overall_status := x_return_status;
1659 End If;
1660 End If;
1661 EXIT WHEN (i = p_oiev_tbl.LAST);
1662 i := p_oiev_tbl.NEXT(i);
1663 END LOOP;
1664 -- return overall status
1665 x_return_status := l_overall_status;
1666 End If;
1667
1668 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1669 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1670 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1671 raise OKC_API.G_EXCEPTION_ERROR;
1672 End If;
1673
1674 -- end activity
1675 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1676 x_msg_data => x_msg_data);
1677 EXCEPTION
1678 when OKC_API.G_EXCEPTION_ERROR then
1679 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1680 p_api_name => l_api_name,
1681 p_pkg_name => g_pkg_name,
1682 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1683 x_msg_count => x_msg_count,
1684 x_msg_data => x_msg_data,
1685 p_api_type => g_api_type);
1686
1687 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1688 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1689 p_api_name => l_api_name,
1690 p_pkg_name => g_pkg_name,
1691 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1692 x_msg_count => x_msg_count,
1693 x_msg_data => x_msg_data,
1694 p_api_type => g_api_type);
1695
1696 when OTHERS then
1697 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1698 p_api_name => l_api_name,
1699 p_pkg_name => g_pkg_name,
1700 p_exc_name => 'OTHERS',
1701 x_msg_count => x_msg_count,
1702 x_msg_data => x_msg_data,
1703 p_api_type => g_api_type);
1704
1705 END Delete_Operation_Instance;
1706
1707 PROCEDURE Lock_Operation_Instance(
1708 p_api_version IN NUMBER,
1709 p_init_msg_list IN VARCHAR2 ,
1710 x_return_status OUT NOCOPY VARCHAR2,
1711 x_msg_count OUT NOCOPY NUMBER,
1712 x_msg_data OUT NOCOPY VARCHAR2,
1713 p_oiev_rec IN oiev_rec_type) IS
1714
1715 l_oiev_rec oiev_rec_type;
1716 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Operation_Instance';
1717 l_api_version CONSTANT NUMBER := 1.0;
1718 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1719 BEGIN
1720 -- call START_ACTIVITY to Create savepoint, check compatibility
1721 -- and initialize message list
1722 l_return_status := OKC_API.START_ACTIVITY(
1723 p_api_name => l_api_name,
1724 p_pkg_name => g_pkg_name,
1725 p_init_msg_list => p_init_msg_list,
1726 l_api_version => l_api_version,
1727 p_api_version => p_api_version,
1728 p_api_type => g_api_type,
1729 x_return_status => x_return_status);
1730
1731 -- check if activity started successfully
1732 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1733 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1734 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1735 raise OKC_API.G_EXCEPTION_ERROR;
1736 End If;
1737
1738 -- call BEFORE user hook
1739 l_oiev_rec := p_oiev_rec;
1740 g_oiev_rec := l_oiev_rec;
1741
1742 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1743 p_package_name => g_pkg_name,
1744 p_procedure_name => l_api_name,
1745 p_before_after => 'B');
1746
1747 -- check return status of user hook call
1748 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1749 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1750 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1751 raise OKC_API.G_EXCEPTION_ERROR;
1752 End If;
1753
1754 -- get values back from user hook call
1755 l_oiev_rec := g_oiev_rec;
1756 l_oiev_rec.id := p_oiev_rec.id;
1757 l_oiev_rec.object_version_number := p_oiev_rec.object_version_number;
1758
1759 -- call procedure in complex API
1760 OKC_OPER_INST_PVT.Lock_Operation_Instance(
1761 p_api_version => p_api_version,
1762 p_init_msg_list => p_init_msg_list,
1763 x_return_status => x_return_status,
1764 x_msg_count => x_msg_count,
1765 x_msg_data => x_msg_data,
1766 p_oiev_rec => l_oiev_rec);
1767
1768 -- check return status
1769 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1770 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1771 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1772 raise OKC_API.G_EXCEPTION_ERROR;
1773 End If;
1774
1775 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1776 p_package_name => g_pkg_name,
1777 p_procedure_name => l_api_name,
1778 p_before_after => 'A');
1779
1780 -- check return status of the user hook call
1781 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1782 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1783 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1784 raise OKC_API.G_EXCEPTION_ERROR;
1785 End If;
1786
1787 -- end activity
1788 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1789 x_msg_data => x_msg_data);
1790 EXCEPTION
1791 when OKC_API.G_EXCEPTION_ERROR then
1792 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1793 p_api_name => l_api_name,
1794 p_pkg_name => g_pkg_name,
1795 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1796 x_msg_count => x_msg_count,
1797 x_msg_data => x_msg_data,
1798 p_api_type => g_api_type);
1799
1800 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1801 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1802 p_api_name => l_api_name,
1803 p_pkg_name => g_pkg_name,
1804 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1805 x_msg_count => x_msg_count,
1806 x_msg_data => x_msg_data,
1807 p_api_type => g_api_type);
1808
1809 when OTHERS then
1810 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1811 p_api_name => l_api_name,
1812 p_pkg_name => g_pkg_name,
1813 p_exc_name => 'OTHERS',
1814 x_msg_count => x_msg_count,
1815 x_msg_data => x_msg_data,
1816 p_api_type => g_api_type);
1817
1818 END Lock_Operation_Instance;
1819
1820 PROCEDURE Lock_Operation_Instance(
1821 p_api_version IN NUMBER,
1822 p_init_msg_list IN VARCHAR2 ,
1823 x_return_status OUT NOCOPY VARCHAR2,
1824 x_msg_count OUT NOCOPY NUMBER,
1825 x_msg_data OUT NOCOPY VARCHAR2,
1826 p_oiev_tbl IN oiev_tbl_type) IS
1827
1828 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Operation_Instance';
1829 l_api_version CONSTANT NUMBER := 1.0;
1830 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1831 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1832 i NUMBER;
1833 BEGIN
1834 -- call START_ACTIVITY to Create savepoint, check compatibility
1835 -- and initialize message list
1836 l_return_status := OKC_API.START_ACTIVITY(
1837 p_api_name => l_api_name,
1838 p_pkg_name => g_pkg_name,
1839 p_init_msg_list => p_init_msg_list,
1840 l_api_version => l_api_version,
1841 p_api_version => p_api_version,
1842 p_api_type => g_api_type,
1843 x_return_status => x_return_status);
1844
1845 -- check if activity started successfully
1846 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1847 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1848 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1849 raise OKC_API.G_EXCEPTION_ERROR;
1850 End If;
1851
1852 If (p_oiev_tbl.COUNT > 0) Then
1853 i := p_oiev_tbl.FIRST;
1854 LOOP
1855 -- call procedure in complex API
1856 OKC_OPER_INST_PUB.Lock_Operation_Instance(
1857 p_api_version => p_api_version,
1858 p_init_msg_list => p_init_msg_list,
1859 x_return_status => x_return_status,
1860 x_msg_count => x_msg_count,
1861 x_msg_data => x_msg_data,
1862 p_oiev_rec => p_oiev_tbl(i));
1863
1864 -- store the highest degree of error
1865 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1866 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1867 l_overall_status := x_return_status;
1868 End If;
1869 End If;
1870 EXIT WHEN (i = p_oiev_tbl.LAST);
1871 i := p_oiev_tbl.NEXT(i);
1872 END LOOP;
1873 -- return overall status
1874 x_return_status := l_overall_status;
1875 End If;
1876
1877 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1878 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1879 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1880 raise OKC_API.G_EXCEPTION_ERROR;
1881 End If;
1882
1883 -- end activity
1884 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1885 x_msg_data => x_msg_data);
1886 EXCEPTION
1887 when OKC_API.G_EXCEPTION_ERROR then
1888 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1889 p_api_name => l_api_name,
1890 p_pkg_name => g_pkg_name,
1891 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1892 x_msg_count => x_msg_count,
1893 x_msg_data => x_msg_data,
1894 p_api_type => g_api_type);
1895
1896 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1897 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1898 p_api_name => l_api_name,
1899 p_pkg_name => g_pkg_name,
1900 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1901 x_msg_count => x_msg_count,
1902 x_msg_data => x_msg_data,
1903 p_api_type => g_api_type);
1904
1905 when OTHERS then
1906 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1907 p_api_name => l_api_name,
1908 p_pkg_name => g_pkg_name,
1909 p_exc_name => 'OTHERS',
1910 x_msg_count => x_msg_count,
1911 x_msg_data => x_msg_data,
1912 p_api_type => g_api_type);
1913
1914 END Lock_Operation_Instance;
1915
1916 PROCEDURE Validate_Operation_Instance(
1917 p_api_version IN NUMBER,
1918 p_init_msg_list IN VARCHAR2 ,
1919 x_return_status OUT NOCOPY VARCHAR2,
1920 x_msg_count OUT NOCOPY NUMBER,
1921 x_msg_data OUT NOCOPY VARCHAR2,
1922 p_oiev_rec IN oiev_rec_type) IS
1923
1924 l_oiev_rec oiev_rec_type;
1925 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Operation_Instance';
1926 l_api_version CONSTANT NUMBER := 1.0;
1927 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1928 BEGIN
1929 -- call START_ACTIVITY to Create savepoint, check compatibility
1930 -- and initialize message list
1931 l_return_status := OKC_API.START_ACTIVITY(
1932 p_api_name => l_api_name,
1933 p_pkg_name => g_pkg_name,
1934 p_init_msg_list => p_init_msg_list,
1935 l_api_version => l_api_version,
1936 p_api_version => p_api_version,
1937 p_api_type => g_api_type,
1938 x_return_status => x_return_status);
1939
1940 -- check if activity started successfully
1941 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1942 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1943 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1944 raise OKC_API.G_EXCEPTION_ERROR;
1945 End If;
1946
1947 -- call BEFORE user hook
1948 l_oiev_rec := p_oiev_rec;
1949 g_oiev_rec := l_oiev_rec;
1950
1951 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1952 p_package_name => g_pkg_name,
1953 p_procedure_name => l_api_name,
1954 p_before_after => 'B');
1955
1956 -- check return status of user hook call
1957 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1958 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1959 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1960 raise OKC_API.G_EXCEPTION_ERROR;
1961 End If;
1962
1963 -- get values back from user hook call
1964 l_oiev_rec := g_oiev_rec;
1965 l_oiev_rec.id := p_oiev_rec.id;
1966 l_oiev_rec.object_version_number := p_oiev_rec.object_version_number;
1967
1968 -- call procedure in complex API
1969 OKC_OPER_INST_PVT.Validate_Operation_Instance(
1970 p_api_version => p_api_version,
1971 p_init_msg_list => p_init_msg_list,
1972 x_return_status => x_return_status,
1973 x_msg_count => x_msg_count,
1974 x_msg_data => x_msg_data,
1975 p_oiev_rec => l_oiev_rec);
1976
1977 -- check return status
1978 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1979 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1980 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1981 raise OKC_API.G_EXCEPTION_ERROR;
1982 End If;
1983
1984 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1985 p_package_name => g_pkg_name,
1986 p_procedure_name => l_api_name,
1987 p_before_after => 'A');
1988
1989 -- check return status of the user hook call
1990 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1991 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1992 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1993 raise OKC_API.G_EXCEPTION_ERROR;
1994 End If;
1995
1996 -- end activity
1997 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1998 x_msg_data => x_msg_data);
1999 EXCEPTION
2000 when OKC_API.G_EXCEPTION_ERROR then
2001 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2002 p_api_name => l_api_name,
2003 p_pkg_name => g_pkg_name,
2004 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2005 x_msg_count => x_msg_count,
2006 x_msg_data => x_msg_data,
2007 p_api_type => g_api_type);
2008
2009 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2010 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2011 p_api_name => l_api_name,
2012 p_pkg_name => g_pkg_name,
2013 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2014 x_msg_count => x_msg_count,
2015 x_msg_data => x_msg_data,
2016 p_api_type => g_api_type);
2017
2018 when OTHERS then
2019 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2020 p_api_name => l_api_name,
2021 p_pkg_name => g_pkg_name,
2022 p_exc_name => 'OTHERS',
2023 x_msg_count => x_msg_count,
2024 x_msg_data => x_msg_data,
2025 p_api_type => g_api_type);
2026
2027 END Validate_Operation_Instance;
2028
2029 PROCEDURE Validate_Operation_Instance(
2030 p_api_version IN NUMBER,
2031 p_init_msg_list IN VARCHAR2 ,
2032 x_return_status OUT NOCOPY VARCHAR2,
2033 x_msg_count OUT NOCOPY NUMBER,
2034 x_msg_data OUT NOCOPY VARCHAR2,
2035 p_oiev_tbl IN oiev_tbl_type) IS
2036
2037 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Operation_Instance';
2038 l_api_version CONSTANT NUMBER := 1.0;
2039 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2040 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2041 i NUMBER;
2042 BEGIN
2043 -- call START_ACTIVITY to Create savepoint, check compatibility
2044 -- and initialize message list
2045 l_return_status := OKC_API.START_ACTIVITY(
2046 p_api_name => l_api_name,
2047 p_pkg_name => g_pkg_name,
2048 p_init_msg_list => p_init_msg_list,
2049 l_api_version => l_api_version,
2050 p_api_version => p_api_version,
2051 p_api_type => g_api_type,
2052 x_return_status => x_return_status);
2053
2054 -- check if activity started successfully
2055 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2056 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2057 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2058 raise OKC_API.G_EXCEPTION_ERROR;
2059 End If;
2060
2061 If (p_oiev_tbl.COUNT > 0) Then
2062 i := p_oiev_tbl.FIRST;
2063 LOOP
2064 -- call procedure in complex API
2065 OKC_OPER_INST_PUB.Validate_Operation_Instance(
2066 p_api_version => p_api_version,
2067 p_init_msg_list => p_init_msg_list,
2068 x_return_status => x_return_status,
2069 x_msg_count => x_msg_count,
2070 x_msg_data => x_msg_data,
2071 p_oiev_rec => p_oiev_tbl(i));
2072
2073 -- store the highest degree of error
2074 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2075 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2076 l_overall_status := x_return_status;
2077 End If;
2078 End If;
2079 EXIT WHEN (i = p_oiev_tbl.LAST);
2080 i := p_oiev_tbl.NEXT(i);
2081 END LOOP;
2082 -- return overall status
2083 x_return_status := l_overall_status;
2084 End If;
2085
2086 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2087 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2088 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2089 raise OKC_API.G_EXCEPTION_ERROR;
2090 End If;
2091
2092 -- end activity
2093 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2094 x_msg_data => x_msg_data);
2095 EXCEPTION
2096 when OKC_API.G_EXCEPTION_ERROR then
2097 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2098 p_api_name => l_api_name,
2099 p_pkg_name => g_pkg_name,
2100 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2101 x_msg_count => x_msg_count,
2102 x_msg_data => x_msg_data,
2103 p_api_type => g_api_type);
2104
2105 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2106 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2107 p_api_name => l_api_name,
2108 p_pkg_name => g_pkg_name,
2109 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2110 x_msg_count => x_msg_count,
2111 x_msg_data => x_msg_data,
2112 p_api_type => g_api_type);
2113
2114 when OTHERS then
2115 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2116 p_api_name => l_api_name,
2117 p_pkg_name => g_pkg_name,
2118 p_exc_name => 'OTHERS',
2119 x_msg_count => x_msg_count,
2120 x_msg_data => x_msg_data,
2121 p_api_type => g_api_type);
2122
2123 END Validate_Operation_Instance;
2124
2125 PROCEDURE Create_Operation_Line(
2126 p_api_version IN NUMBER,
2127 p_init_msg_list IN VARCHAR2 ,
2128 x_return_status OUT NOCOPY VARCHAR2,
2129 x_msg_count OUT NOCOPY NUMBER,
2130 x_msg_data OUT NOCOPY VARCHAR2,
2131 p_olev_rec IN olev_rec_type,
2132 x_olev_rec OUT NOCOPY olev_rec_type) IS
2133
2134 l_olev_rec olev_rec_type;
2135 l_api_name CONSTANT VARCHAR2(30) := 'Create_Operation_Line';
2136 l_api_version CONSTANT NUMBER := 1.0;
2137 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2138 BEGIN
2139 -- call START_ACTIVITY to Create savepoint, check compatibility
2140 -- and initialize message list
2141 l_return_status := OKC_API.START_ACTIVITY(
2142 p_api_name => l_api_name,
2143 p_pkg_name => g_pkg_name,
2144 p_init_msg_list => p_init_msg_list,
2145 l_api_version => l_api_version,
2146 p_api_version => p_api_version,
2147 p_api_type => g_api_type,
2148 x_return_status => x_return_status);
2149
2150 -- check if activity started successfully
2151 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2152 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2153 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2154 raise OKC_API.G_EXCEPTION_ERROR;
2155 End If;
2156
2157 -- call BEFORE user hook
2158 l_olev_rec := p_olev_rec;
2159 g_olev_rec := l_olev_rec;
2160
2161 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2162 p_package_name => g_pkg_name,
2163 p_procedure_name => l_api_name,
2164 p_before_after => 'B');
2165
2166 -- check return status of user hook call
2167 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2168 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2169 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2170 raise OKC_API.G_EXCEPTION_ERROR;
2171 End If;
2172
2173 -- get values back from user hook call
2174 l_olev_rec := g_olev_rec;
2175 l_olev_rec.id := p_olev_rec.id;
2176 l_olev_rec.object_version_number := p_olev_rec.object_version_number;
2177
2178 -- call procedure in complex API
2179 OKC_OPER_INST_PVT.Create_Operation_Line(
2180 p_api_version => p_api_version,
2181 p_init_msg_list => p_init_msg_list,
2182 x_return_status => x_return_status,
2183 x_msg_count => x_msg_count,
2184 x_msg_data => x_msg_data,
2185 p_olev_rec => l_olev_rec,
2186 x_olev_rec => x_olev_rec);
2187
2188 -- check return status
2189 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2190 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2191 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2192 raise OKC_API.G_EXCEPTION_ERROR;
2193 End If;
2194
2195 -- call AFTER user hook
2196 g_olev_rec := x_olev_rec;
2197
2198 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2199 p_package_name => g_pkg_name,
2200 p_procedure_name => l_api_name,
2201 p_before_after => 'A');
2202
2203 -- check return status of the user hook call
2204 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2205 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2206 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2207 raise OKC_API.G_EXCEPTION_ERROR;
2208 End If;
2209
2210 -- end activity
2211 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2212 x_msg_data => x_msg_data);
2213 EXCEPTION
2214 when OKC_API.G_EXCEPTION_ERROR then
2215 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2216 p_api_name => l_api_name,
2217 p_pkg_name => g_pkg_name,
2218 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2219 x_msg_count => x_msg_count,
2220 x_msg_data => x_msg_data,
2221 p_api_type => g_api_type);
2222
2223 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2224 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2225 p_api_name => l_api_name,
2226 p_pkg_name => g_pkg_name,
2227 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2228 x_msg_count => x_msg_count,
2229 x_msg_data => x_msg_data,
2230 p_api_type => g_api_type);
2231
2232 when OTHERS then
2233 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2234 p_api_name => l_api_name,
2235 p_pkg_name => g_pkg_name,
2236 p_exc_name => 'OTHERS',
2237 x_msg_count => x_msg_count,
2238 x_msg_data => x_msg_data,
2239 p_api_type => g_api_type);
2240
2241 END Create_Operation_Line;
2242
2243 PROCEDURE Create_Operation_Line(
2244 p_api_version IN NUMBER,
2245 p_init_msg_list IN VARCHAR2 ,
2246 x_return_status OUT NOCOPY VARCHAR2,
2247 x_msg_count OUT NOCOPY NUMBER,
2248 x_msg_data OUT NOCOPY VARCHAR2,
2249 p_olev_tbl IN olev_tbl_type,
2250 x_olev_tbl OUT NOCOPY olev_tbl_type) IS
2251
2252 l_api_name CONSTANT VARCHAR2(30) := 'Create_Operation_Line';
2253 l_api_version CONSTANT NUMBER := 1.0;
2254 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2255 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2256 i NUMBER;
2257 BEGIN
2258 -- call START_ACTIVITY to Create savepoint, check compatibility
2259 -- and initialize message list
2260 l_return_status := OKC_API.START_ACTIVITY(
2261 p_api_name => l_api_name,
2262 p_pkg_name => g_pkg_name,
2263 p_init_msg_list => p_init_msg_list,
2264 l_api_version => l_api_version,
2265 p_api_version => p_api_version,
2266 p_api_type => g_api_type,
2267 x_return_status => x_return_status);
2268
2269 -- check if activity started successfully
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 If (p_olev_tbl.COUNT > 0) Then
2277 i := p_olev_tbl.FIRST;
2278 LOOP
2279 -- call procedure in public API for a record
2280 OKC_OPER_INST_PUB.Create_Operation_Line(
2281 p_api_version => p_api_version,
2282 p_init_msg_list => p_init_msg_list,
2283 x_return_status => x_return_status,
2284 x_msg_count => x_msg_count,
2285 x_msg_data => x_msg_data,
2286 p_olev_rec => p_olev_tbl(i),
2287 x_olev_rec => x_olev_tbl(i));
2288
2289 -- store the highest degree of error
2290 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2291 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2292 l_overall_status := x_return_status;
2293 End If;
2294 End If;
2295 EXIT WHEN (i = p_olev_tbl.LAST);
2296 i := p_olev_tbl.NEXT(i);
2297 END LOOP;
2298 -- return overall status
2299 x_return_status := l_overall_status;
2300 End If;
2301
2302 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2303 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2304 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2305 raise OKC_API.G_EXCEPTION_ERROR;
2306 End If;
2307
2308 -- end activity
2309 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2310 x_msg_data => x_msg_data);
2311 EXCEPTION
2312 when OKC_API.G_EXCEPTION_ERROR then
2313 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2314 p_api_name => l_api_name,
2315 p_pkg_name => g_pkg_name,
2316 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2317 x_msg_count => x_msg_count,
2318 x_msg_data => x_msg_data,
2319 p_api_type => g_api_type);
2320
2321 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2322 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2323 p_api_name => l_api_name,
2324 p_pkg_name => g_pkg_name,
2325 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2326 x_msg_count => x_msg_count,
2327 x_msg_data => x_msg_data,
2328 p_api_type => g_api_type);
2329
2330 when OTHERS then
2331 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2332 p_api_name => l_api_name,
2333 p_pkg_name => g_pkg_name,
2334 p_exc_name => 'OTHERS',
2335 x_msg_count => x_msg_count,
2336 x_msg_data => x_msg_data,
2337 p_api_type => g_api_type);
2338
2339 END Create_Operation_Line;
2340
2341 PROCEDURE Update_Operation_Line(
2342 p_api_version IN NUMBER,
2343 p_init_msg_list IN VARCHAR2 ,
2344 x_return_status OUT NOCOPY VARCHAR2,
2345 x_msg_count OUT NOCOPY NUMBER,
2346 x_msg_data OUT NOCOPY VARCHAR2,
2347 p_olev_rec IN olev_rec_type,
2348 x_olev_rec OUT NOCOPY olev_rec_type) IS
2349
2350 l_olev_rec olev_rec_type;
2351 l_api_name CONSTANT VARCHAR2(30) := 'Update_Operation_Line';
2352 l_api_version CONSTANT NUMBER := 1.0;
2353 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2354 BEGIN
2355 -- call START_ACTIVITY to Create savepoint, check compatibility
2356 -- and initialize message list
2357 l_return_status := OKC_API.START_ACTIVITY(
2358 p_api_name => l_api_name,
2359 p_pkg_name => g_pkg_name,
2360 p_init_msg_list => p_init_msg_list,
2361 l_api_version => l_api_version,
2362 p_api_version => p_api_version,
2363 p_api_type => g_api_type,
2364 x_return_status => x_return_status);
2365
2366 -- check if activity started successfully
2367 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2368 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2369 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2370 raise OKC_API.G_EXCEPTION_ERROR;
2371 End If;
2372
2373 -- call BEFORE user hook
2374 l_olev_rec := p_olev_rec;
2375 g_olev_rec := l_olev_rec;
2376
2377 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2378 p_package_name => g_pkg_name,
2379 p_procedure_name => l_api_name,
2380 p_before_after => 'B');
2381
2382 -- check return status of user hook call
2383 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2384 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2385 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2386 raise OKC_API.G_EXCEPTION_ERROR;
2387 End If;
2388
2389 -- get values back from user hook call
2390 l_olev_rec := g_olev_rec;
2391 l_olev_rec.id := p_olev_rec.id;
2392 l_olev_rec.object_version_number := p_olev_rec.object_version_number;
2393
2394 -- call procedure in complex API
2395 OKC_OPER_INST_PVT.Update_Operation_Line(
2396 p_api_version => p_api_version,
2397 p_init_msg_list => p_init_msg_list,
2398 x_return_status => x_return_status,
2399 x_msg_count => x_msg_count,
2400 x_msg_data => x_msg_data,
2401 p_olev_rec => l_olev_rec,
2402 x_olev_rec => x_olev_rec);
2403
2404 -- check return status
2405 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2406 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2407 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2408 raise OKC_API.G_EXCEPTION_ERROR;
2409 End If;
2410
2411 -- call AFTER user hook
2412 g_olev_rec := x_olev_rec;
2413
2414 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2415 p_package_name => g_pkg_name,
2416 p_procedure_name => l_api_name,
2417 p_before_after => 'A');
2418
2419 -- check return status of the user hook call
2420 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2421 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2422 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2423 raise OKC_API.G_EXCEPTION_ERROR;
2424 End If;
2425
2426 -- end activity
2427 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2428 x_msg_data => x_msg_data);
2429 EXCEPTION
2430 when OKC_API.G_EXCEPTION_ERROR then
2431 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2432 p_api_name => l_api_name,
2433 p_pkg_name => g_pkg_name,
2434 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2435 x_msg_count => x_msg_count,
2436 x_msg_data => x_msg_data,
2437 p_api_type => g_api_type);
2438
2439 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2440 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2441 p_api_name => l_api_name,
2442 p_pkg_name => g_pkg_name,
2443 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2444 x_msg_count => x_msg_count,
2445 x_msg_data => x_msg_data,
2446 p_api_type => g_api_type);
2447
2448 when OTHERS then
2449 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2450 p_api_name => l_api_name,
2451 p_pkg_name => g_pkg_name,
2452 p_exc_name => 'OTHERS',
2453 x_msg_count => x_msg_count,
2454 x_msg_data => x_msg_data,
2455 p_api_type => g_api_type);
2456
2457 END Update_Operation_Line;
2458
2459 PROCEDURE Update_Operation_Line(
2460 p_api_version IN NUMBER,
2461 p_init_msg_list IN VARCHAR2 ,
2462 x_return_status OUT NOCOPY VARCHAR2,
2463 x_msg_count OUT NOCOPY NUMBER,
2464 x_msg_data OUT NOCOPY VARCHAR2,
2465 p_olev_tbl IN olev_tbl_type,
2466 x_olev_tbl OUT NOCOPY olev_tbl_type) IS
2467
2468 l_api_name CONSTANT VARCHAR2(30) := 'Update_Operation_Line';
2469 l_api_version CONSTANT NUMBER := 1.0;
2470 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2471 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2472 i NUMBER;
2473 BEGIN
2474 -- call START_ACTIVITY to Create savepoint, check compatibility
2475 -- and initialize message list
2476 l_return_status := OKC_API.START_ACTIVITY(
2477 p_api_name => l_api_name,
2478 p_pkg_name => g_pkg_name,
2479 p_init_msg_list => p_init_msg_list,
2480 l_api_version => l_api_version,
2481 p_api_version => p_api_version,
2482 p_api_type => g_api_type,
2483 x_return_status => x_return_status);
2484
2485 -- check if activity started successfully
2486 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2487 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2488 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2489 raise OKC_API.G_EXCEPTION_ERROR;
2490 End If;
2491
2492 If (p_olev_tbl.COUNT > 0) Then
2493 i := p_olev_tbl.FIRST;
2494 LOOP
2495 -- call procedure in complex API
2496 OKC_OPER_INST_PUB.Update_Operation_Line(
2497 p_api_version => p_api_version,
2498 p_init_msg_list => p_init_msg_list,
2499 x_return_status => x_return_status,
2500 x_msg_count => x_msg_count,
2501 x_msg_data => x_msg_data,
2502 p_olev_rec => p_olev_tbl(i),
2503 x_olev_rec => x_olev_tbl(i));
2504
2505 -- store the highest degree of error
2506 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2507 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2508 l_overall_status := x_return_status;
2509 End If;
2510 End If;
2511 EXIT WHEN (i = p_olev_tbl.LAST);
2512 i := p_olev_tbl.NEXT(i);
2513 END LOOP;
2514 -- return overall status
2515 x_return_status := l_overall_status;
2516 End If;
2517
2518 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2519 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2520 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2521 raise OKC_API.G_EXCEPTION_ERROR;
2522 End If;
2523
2524 -- end activity
2525 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2526 x_msg_data => x_msg_data);
2527 EXCEPTION
2528 when OKC_API.G_EXCEPTION_ERROR then
2529 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2530 p_api_name => l_api_name,
2531 p_pkg_name => g_pkg_name,
2532 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2533 x_msg_count => x_msg_count,
2534 x_msg_data => x_msg_data,
2535 p_api_type => g_api_type);
2536
2537 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2538 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2539 p_api_name => l_api_name,
2540 p_pkg_name => g_pkg_name,
2541 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2542 x_msg_count => x_msg_count,
2543 x_msg_data => x_msg_data,
2544 p_api_type => g_api_type);
2545
2546 when OTHERS then
2547 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2548 p_api_name => l_api_name,
2549 p_pkg_name => g_pkg_name,
2550 p_exc_name => 'OTHERS',
2551 x_msg_count => x_msg_count,
2552 x_msg_data => x_msg_data,
2553 p_api_type => g_api_type);
2554
2555 END Update_Operation_Line;
2556
2557 PROCEDURE Delete_Operation_Line(
2558 p_api_version IN NUMBER,
2559 p_init_msg_list IN VARCHAR2 ,
2560 x_return_status OUT NOCOPY VARCHAR2,
2561 x_msg_count OUT NOCOPY NUMBER,
2562 x_msg_data OUT NOCOPY VARCHAR2,
2563 p_olev_rec IN olev_rec_type) IS
2564
2565 l_olev_rec olev_rec_type;
2566 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Operation_Line';
2567 l_api_version CONSTANT NUMBER := 1.0;
2568 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2569 BEGIN
2570 -- call START_ACTIVITY to Create savepoint, check compatibility
2571 -- and initialize message list
2572 l_return_status := OKC_API.START_ACTIVITY(
2573 p_api_name => l_api_name,
2574 p_pkg_name => g_pkg_name,
2575 p_init_msg_list => p_init_msg_list,
2576 l_api_version => l_api_version,
2577 p_api_version => p_api_version,
2578 p_api_type => g_api_type,
2579 x_return_status => x_return_status);
2580
2581 -- check if activity started successfully
2582 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2583 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2584 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2585 raise OKC_API.G_EXCEPTION_ERROR;
2586 End If;
2587
2588 -- call BEFORE user hook
2589 l_olev_rec := p_olev_rec;
2590 g_olev_rec := l_olev_rec;
2591
2592 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2593 p_package_name => g_pkg_name,
2594 p_procedure_name => l_api_name,
2595 p_before_after => 'B');
2596
2597 -- check return status of user hook call
2598 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2599 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2600 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2601 raise OKC_API.G_EXCEPTION_ERROR;
2602 End If;
2603
2604 -- get values back from user hook call
2605 l_olev_rec := g_olev_rec;
2606 l_olev_rec.id := p_olev_rec.id;
2607 l_olev_rec.object_version_number := p_olev_rec.object_version_number;
2608
2609 -- call procedure in complex API
2610 OKC_OPER_INST_PVT.Delete_Operation_Line(
2611 p_api_version => p_api_version,
2612 p_init_msg_list => p_init_msg_list,
2613 x_return_status => x_return_status,
2614 x_msg_count => x_msg_count,
2615 x_msg_data => x_msg_data,
2616 p_olev_rec => l_olev_rec);
2617
2618 -- check return status
2619 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2620 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2621 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2622 raise OKC_API.G_EXCEPTION_ERROR;
2623 End If;
2624
2625 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2626 p_package_name => g_pkg_name,
2627 p_procedure_name => l_api_name,
2628 p_before_after => 'A');
2629
2630 -- check return status of the user hook call
2631 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2632 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2633 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2634 raise OKC_API.G_EXCEPTION_ERROR;
2635 End If;
2636
2637 -- end activity
2638 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2639 x_msg_data => x_msg_data);
2640 EXCEPTION
2641 when OKC_API.G_EXCEPTION_ERROR then
2642 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2643 p_api_name => l_api_name,
2644 p_pkg_name => g_pkg_name,
2645 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2646 x_msg_count => x_msg_count,
2647 x_msg_data => x_msg_data,
2648 p_api_type => g_api_type);
2649
2650 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2651 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2652 p_api_name => l_api_name,
2653 p_pkg_name => g_pkg_name,
2654 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2655 x_msg_count => x_msg_count,
2656 x_msg_data => x_msg_data,
2657 p_api_type => g_api_type);
2658
2659 when OTHERS then
2660 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2661 p_api_name => l_api_name,
2662 p_pkg_name => g_pkg_name,
2663 p_exc_name => 'OTHERS',
2664 x_msg_count => x_msg_count,
2665 x_msg_data => x_msg_data,
2666 p_api_type => g_api_type);
2667
2668 END Delete_Operation_Line;
2669
2670 PROCEDURE Delete_Operation_Line(
2671 p_api_version IN NUMBER,
2672 p_init_msg_list IN VARCHAR2 ,
2673 x_return_status OUT NOCOPY VARCHAR2,
2674 x_msg_count OUT NOCOPY NUMBER,
2675 x_msg_data OUT NOCOPY VARCHAR2,
2676 p_olev_tbl IN olev_tbl_type) IS
2677
2678 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Operation_Line';
2679 l_api_version CONSTANT NUMBER := 1.0;
2680 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2681 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2682 i NUMBER;
2683 BEGIN
2684 -- call START_ACTIVITY to Create savepoint, check compatibility
2685 -- and initialize message list
2686 l_return_status := OKC_API.START_ACTIVITY(
2687 p_api_name => l_api_name,
2688 p_pkg_name => g_pkg_name,
2689 p_init_msg_list => p_init_msg_list,
2690 l_api_version => l_api_version,
2691 p_api_version => p_api_version,
2692 p_api_type => g_api_type,
2693 x_return_status => x_return_status);
2694
2695 -- check if activity started successfully
2696 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2697 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2698 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2699 raise OKC_API.G_EXCEPTION_ERROR;
2700 End If;
2701
2702 If (p_olev_tbl.COUNT > 0) Then
2703 i := p_olev_tbl.FIRST;
2704 LOOP
2705 -- call procedure in complex API
2706 OKC_OPER_INST_PUB.Delete_Operation_Line(
2707 p_api_version => p_api_version,
2708 p_init_msg_list => p_init_msg_list,
2709 x_return_status => x_return_status,
2710 x_msg_count => x_msg_count,
2711 x_msg_data => x_msg_data,
2712 p_olev_rec => p_olev_tbl(i));
2713
2714 -- store the highest degree of error
2715 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2716 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2717 l_overall_status := x_return_status;
2718 End If;
2719 End If;
2720 EXIT WHEN (i = p_olev_tbl.LAST);
2721 i := p_olev_tbl.NEXT(i);
2722 END LOOP;
2723 -- return overall status
2724 x_return_status := l_overall_status;
2725 End If;
2726
2727 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2728 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2729 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2730 raise OKC_API.G_EXCEPTION_ERROR;
2731 End If;
2732
2733 -- end activity
2734 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2735 x_msg_data => x_msg_data);
2736 EXCEPTION
2737 when OKC_API.G_EXCEPTION_ERROR then
2738 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2739 p_api_name => l_api_name,
2740 p_pkg_name => g_pkg_name,
2741 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2742 x_msg_count => x_msg_count,
2743 x_msg_data => x_msg_data,
2744 p_api_type => g_api_type);
2745
2746 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2747 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2748 p_api_name => l_api_name,
2749 p_pkg_name => g_pkg_name,
2750 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2751 x_msg_count => x_msg_count,
2752 x_msg_data => x_msg_data,
2753 p_api_type => g_api_type);
2754
2755 when OTHERS then
2756 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2757 p_api_name => l_api_name,
2758 p_pkg_name => g_pkg_name,
2759 p_exc_name => 'OTHERS',
2760 x_msg_count => x_msg_count,
2761 x_msg_data => x_msg_data,
2762 p_api_type => g_api_type);
2763
2764 END Delete_Operation_Line;
2765
2766 PROCEDURE Lock_Operation_Line(
2767 p_api_version IN NUMBER,
2768 p_init_msg_list IN VARCHAR2 ,
2769 x_return_status OUT NOCOPY VARCHAR2,
2770 x_msg_count OUT NOCOPY NUMBER,
2771 x_msg_data OUT NOCOPY VARCHAR2,
2772 p_olev_rec IN olev_rec_type) IS
2773
2774 l_olev_rec olev_rec_type;
2775 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Operation_Line';
2776 l_api_version CONSTANT NUMBER := 1.0;
2777 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2778 BEGIN
2779 -- call START_ACTIVITY to Create savepoint, check compatibility
2780 -- and initialize message list
2781 l_return_status := OKC_API.START_ACTIVITY(
2782 p_api_name => l_api_name,
2783 p_pkg_name => g_pkg_name,
2784 p_init_msg_list => p_init_msg_list,
2785 l_api_version => l_api_version,
2786 p_api_version => p_api_version,
2787 p_api_type => g_api_type,
2788 x_return_status => x_return_status);
2789
2790 -- check if activity started successfully
2791 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2792 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2793 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2794 raise OKC_API.G_EXCEPTION_ERROR;
2795 End If;
2796
2797 -- call BEFORE user hook
2798 l_olev_rec := p_olev_rec;
2799 g_olev_rec := l_olev_rec;
2800
2801 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2802 p_package_name => g_pkg_name,
2803 p_procedure_name => l_api_name,
2804 p_before_after => 'B');
2805
2806 -- check return status of user hook call
2807 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2808 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2809 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2810 raise OKC_API.G_EXCEPTION_ERROR;
2811 End If;
2812
2813 -- get values back from user hook call
2814 l_olev_rec := g_olev_rec;
2815 l_olev_rec.id := p_olev_rec.id;
2816 l_olev_rec.object_version_number := p_olev_rec.object_version_number;
2817
2818 -- call procedure in complex API
2819 OKC_OPER_INST_PVT.Lock_Operation_Line(
2820 p_api_version => p_api_version,
2821 p_init_msg_list => p_init_msg_list,
2822 x_return_status => x_return_status,
2823 x_msg_count => x_msg_count,
2824 x_msg_data => x_msg_data,
2825 p_olev_rec => l_olev_rec);
2826
2827 -- check return status
2828 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2829 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2830 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2831 raise OKC_API.G_EXCEPTION_ERROR;
2832 End If;
2833
2834 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2835 p_package_name => g_pkg_name,
2836 p_procedure_name => l_api_name,
2837 p_before_after => 'A');
2838
2839 -- check return status of the user hook call
2840 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2841 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2842 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2843 raise OKC_API.G_EXCEPTION_ERROR;
2844 End If;
2845
2846 -- end activity
2847 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2848 x_msg_data => x_msg_data);
2849 EXCEPTION
2850 when OKC_API.G_EXCEPTION_ERROR then
2851 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2852 p_api_name => l_api_name,
2853 p_pkg_name => g_pkg_name,
2854 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2855 x_msg_count => x_msg_count,
2856 x_msg_data => x_msg_data,
2857 p_api_type => g_api_type);
2858
2859 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2860 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2861 p_api_name => l_api_name,
2862 p_pkg_name => g_pkg_name,
2863 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2864 x_msg_count => x_msg_count,
2865 x_msg_data => x_msg_data,
2866 p_api_type => g_api_type);
2867
2868 when OTHERS then
2869 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2870 p_api_name => l_api_name,
2871 p_pkg_name => g_pkg_name,
2872 p_exc_name => 'OTHERS',
2873 x_msg_count => x_msg_count,
2874 x_msg_data => x_msg_data,
2875 p_api_type => g_api_type);
2876
2877 END Lock_Operation_Line;
2878
2879 PROCEDURE Lock_Operation_Line(
2880 p_api_version IN NUMBER,
2881 p_init_msg_list IN VARCHAR2 ,
2882 x_return_status OUT NOCOPY VARCHAR2,
2883 x_msg_count OUT NOCOPY NUMBER,
2884 x_msg_data OUT NOCOPY VARCHAR2,
2885 p_olev_tbl IN olev_tbl_type) IS
2886
2887 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Operation_Line';
2888 l_api_version CONSTANT NUMBER := 1.0;
2889 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2890 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2891 i NUMBER;
2892 BEGIN
2893 -- call START_ACTIVITY to Create savepoint, check compatibility
2894 -- and initialize message list
2895 l_return_status := OKC_API.START_ACTIVITY(
2896 p_api_name => l_api_name,
2897 p_pkg_name => g_pkg_name,
2898 p_init_msg_list => p_init_msg_list,
2899 l_api_version => l_api_version,
2900 p_api_version => p_api_version,
2901 p_api_type => g_api_type,
2902 x_return_status => x_return_status);
2903
2904 -- check if activity started successfully
2905 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2906 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2907 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2908 raise OKC_API.G_EXCEPTION_ERROR;
2909 End If;
2910
2911 If (p_olev_tbl.COUNT > 0) Then
2912 i := p_olev_tbl.FIRST;
2913 LOOP
2914 -- call procedure in complex API
2915 OKC_OPER_INST_PUB.Lock_Operation_Line(
2916 p_api_version => p_api_version,
2917 p_init_msg_list => p_init_msg_list,
2918 x_return_status => x_return_status,
2919 x_msg_count => x_msg_count,
2920 x_msg_data => x_msg_data,
2921 p_olev_rec => p_olev_tbl(i));
2922
2923 -- store the highest degree of error
2924 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2925 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2926 l_overall_status := x_return_status;
2927 End If;
2928 End If;
2929 EXIT WHEN (i = p_olev_tbl.LAST);
2930 i := p_olev_tbl.NEXT(i);
2931 END LOOP;
2932 -- return overall status
2933 x_return_status := l_overall_status;
2934 End If;
2935
2936 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2937 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2938 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2939 raise OKC_API.G_EXCEPTION_ERROR;
2940 End If;
2941
2942 -- end activity
2943 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2944 x_msg_data => x_msg_data);
2945 EXCEPTION
2946 when OKC_API.G_EXCEPTION_ERROR then
2947 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2948 p_api_name => l_api_name,
2949 p_pkg_name => g_pkg_name,
2950 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2951 x_msg_count => x_msg_count,
2952 x_msg_data => x_msg_data,
2953 p_api_type => g_api_type);
2954
2955 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2956 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2957 p_api_name => l_api_name,
2958 p_pkg_name => g_pkg_name,
2959 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2960 x_msg_count => x_msg_count,
2961 x_msg_data => x_msg_data,
2962 p_api_type => g_api_type);
2963
2964 when OTHERS then
2965 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2966 p_api_name => l_api_name,
2967 p_pkg_name => g_pkg_name,
2968 p_exc_name => 'OTHERS',
2969 x_msg_count => x_msg_count,
2970 x_msg_data => x_msg_data,
2971 p_api_type => g_api_type);
2972
2973 END Lock_Operation_Line;
2974
2975 PROCEDURE Validate_Operation_Line(
2976 p_api_version IN NUMBER,
2977 p_init_msg_list IN VARCHAR2 ,
2978 x_return_status OUT NOCOPY VARCHAR2,
2979 x_msg_count OUT NOCOPY NUMBER,
2980 x_msg_data OUT NOCOPY VARCHAR2,
2981 p_olev_rec IN olev_rec_type) IS
2982
2983 l_olev_rec olev_rec_type;
2984 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Operation_Line';
2985 l_api_version CONSTANT NUMBER := 1.0;
2986 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2987 BEGIN
2988 -- call START_ACTIVITY to Create savepoint, check compatibility
2989 -- and initialize message list
2990 l_return_status := OKC_API.START_ACTIVITY(
2991 p_api_name => l_api_name,
2992 p_pkg_name => g_pkg_name,
2993 p_init_msg_list => p_init_msg_list,
2994 l_api_version => l_api_version,
2995 p_api_version => p_api_version,
2996 p_api_type => g_api_type,
2997 x_return_status => x_return_status);
2998
2999 -- check if activity started successfully
3000 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3001 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3002 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3003 raise OKC_API.G_EXCEPTION_ERROR;
3004 End If;
3005
3006 -- call BEFORE user hook
3007 l_olev_rec := p_olev_rec;
3008 g_olev_rec := l_olev_rec;
3009
3010 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3011 p_package_name => g_pkg_name,
3012 p_procedure_name => l_api_name,
3013 p_before_after => 'B');
3014
3015 -- check return status of user hook call
3016 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3017 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3018 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3019 raise OKC_API.G_EXCEPTION_ERROR;
3020 End If;
3021
3022 -- get values back from user hook call
3023 l_olev_rec := g_olev_rec;
3024 l_olev_rec.id := p_olev_rec.id;
3025 l_olev_rec.object_version_number := p_olev_rec.object_version_number;
3026
3027 -- call procedure in complex API
3028 OKC_OPER_INST_PVT.Validate_Operation_Line(
3029 p_api_version => p_api_version,
3030 p_init_msg_list => p_init_msg_list,
3031 x_return_status => x_return_status,
3032 x_msg_count => x_msg_count,
3033 x_msg_data => x_msg_data,
3034 p_olev_rec => l_olev_rec);
3035
3036 -- check return status
3037 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3038 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3039 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3040 raise OKC_API.G_EXCEPTION_ERROR;
3041 End If;
3042
3043 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3044 p_package_name => g_pkg_name,
3045 p_procedure_name => l_api_name,
3046 p_before_after => 'A');
3047
3048 -- check return status of the user hook call
3049 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3050 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3051 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3052 raise OKC_API.G_EXCEPTION_ERROR;
3053 End If;
3054
3055 -- end activity
3056 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3057 x_msg_data => x_msg_data);
3058 EXCEPTION
3059 when OKC_API.G_EXCEPTION_ERROR then
3060 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3061 p_api_name => l_api_name,
3062 p_pkg_name => g_pkg_name,
3063 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3064 x_msg_count => x_msg_count,
3065 x_msg_data => x_msg_data,
3066 p_api_type => g_api_type);
3067
3068 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3069 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3070 p_api_name => l_api_name,
3071 p_pkg_name => g_pkg_name,
3072 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3073 x_msg_count => x_msg_count,
3074 x_msg_data => x_msg_data,
3075 p_api_type => g_api_type);
3076
3077 when OTHERS then
3078 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3079 p_api_name => l_api_name,
3080 p_pkg_name => g_pkg_name,
3081 p_exc_name => 'OTHERS',
3082 x_msg_count => x_msg_count,
3083 x_msg_data => x_msg_data,
3084 p_api_type => g_api_type);
3085
3086 END Validate_Operation_Line;
3087
3088 PROCEDURE Validate_Operation_Line(
3089 p_api_version IN NUMBER,
3090 p_init_msg_list IN VARCHAR2 ,
3091 x_return_status OUT NOCOPY VARCHAR2,
3092 x_msg_count OUT NOCOPY NUMBER,
3093 x_msg_data OUT NOCOPY VARCHAR2,
3094 p_olev_tbl IN olev_tbl_type) IS
3095
3096 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Operation_Line';
3097 l_api_version CONSTANT NUMBER := 1.0;
3098 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3099 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3100 i NUMBER;
3101 BEGIN
3102 -- call START_ACTIVITY to Create savepoint, check compatibility
3103 -- and initialize message list
3104 l_return_status := OKC_API.START_ACTIVITY(
3105 p_api_name => l_api_name,
3106 p_pkg_name => g_pkg_name,
3107 p_init_msg_list => p_init_msg_list,
3108 l_api_version => l_api_version,
3109 p_api_version => p_api_version,
3110 p_api_type => g_api_type,
3111 x_return_status => x_return_status);
3112
3113 -- check if activity started successfully
3114 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3115 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3116 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3117 raise OKC_API.G_EXCEPTION_ERROR;
3118 End If;
3119
3120 If (p_olev_tbl.COUNT > 0) Then
3121 i := p_olev_tbl.FIRST;
3122 LOOP
3123 -- call procedure in complex API
3124 OKC_OPER_INST_PUB.Validate_Operation_Line(
3125 p_api_version => p_api_version,
3126 p_init_msg_list => p_init_msg_list,
3127 x_return_status => x_return_status,
3128 x_msg_count => x_msg_count,
3129 x_msg_data => x_msg_data,
3130 p_olev_rec => p_olev_tbl(i));
3131
3132 -- store the highest degree of error
3133 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3134 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3135 l_overall_status := x_return_status;
3136 End If;
3137 End If;
3138 EXIT WHEN (i = p_olev_tbl.LAST);
3139 i := p_olev_tbl.NEXT(i);
3140 END LOOP;
3141 -- return overall status
3142 x_return_status := l_overall_status;
3143 End If;
3144
3145 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3146 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3147 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3148 raise OKC_API.G_EXCEPTION_ERROR;
3149 End If;
3150
3151 -- end activity
3152 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3153 x_msg_data => x_msg_data);
3154 EXCEPTION
3155 when OKC_API.G_EXCEPTION_ERROR then
3156 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3157 p_api_name => l_api_name,
3158 p_pkg_name => g_pkg_name,
3159 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3160 x_msg_count => x_msg_count,
3161 x_msg_data => x_msg_data,
3162 p_api_type => g_api_type);
3163
3164 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3165 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3166 p_api_name => l_api_name,
3167 p_pkg_name => g_pkg_name,
3168 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3169 x_msg_count => x_msg_count,
3170 x_msg_data => x_msg_data,
3171 p_api_type => g_api_type);
3172
3173 when OTHERS then
3174 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3175 p_api_name => l_api_name,
3176 p_pkg_name => g_pkg_name,
3177 p_exc_name => 'OTHERS',
3178 x_msg_count => x_msg_count,
3179 x_msg_data => x_msg_data,
3180 p_api_type => g_api_type);
3181
3182 END Validate_Operation_Line;
3183
3184 PROCEDURE Create_Masschange_Dtls(
3185 p_api_version IN NUMBER,
3186 p_init_msg_list IN VARCHAR2 ,
3187 x_return_status OUT NOCOPY VARCHAR2,
3188 x_msg_count OUT NOCOPY NUMBER,
3189 x_msg_data OUT NOCOPY VARCHAR2,
3190 p_mrdv_rec IN mrdv_rec_type,
3191 x_mrdv_rec OUT NOCOPY mrdv_rec_type) IS
3192
3193 l_mrdv_rec mrdv_rec_type;
3194 l_api_name CONSTANT VARCHAR2(30) := 'Create_Masschange_Dtls';
3195 l_api_version CONSTANT NUMBER := 1.0;
3196 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3197 BEGIN
3198 -- call START_ACTIVITY to Create savepoint, check compatibility
3199 -- and initialize message list
3200 l_return_status := OKC_API.START_ACTIVITY(
3201 p_api_name => l_api_name,
3202 p_pkg_name => g_pkg_name,
3203 p_init_msg_list => p_init_msg_list,
3204 l_api_version => l_api_version,
3205 p_api_version => p_api_version,
3206 p_api_type => g_api_type,
3207 x_return_status => x_return_status);
3208
3209 -- check if activity started successfully
3210 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3211 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3212 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3213 raise OKC_API.G_EXCEPTION_ERROR;
3214 End If;
3215
3216 -- call BEFORE user hook
3217 l_mrdv_rec := p_mrdv_rec;
3218 g_mrdv_rec := l_mrdv_rec;
3219
3220 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3221 p_package_name => g_pkg_name,
3222 p_procedure_name => l_api_name,
3223 p_before_after => 'B');
3224
3225 -- check return status of user hook call
3226 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3227 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3228 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3229 raise OKC_API.G_EXCEPTION_ERROR;
3230 End If;
3231
3232 -- get values back from user hook call
3233 l_mrdv_rec := g_mrdv_rec;
3234 l_mrdv_rec.id := p_mrdv_rec.id;
3235 l_mrdv_rec.object_version_number := p_mrdv_rec.object_version_number;
3236
3237 -- call procedure in complex API
3238 OKC_OPER_INST_PVT.Create_Masschange_Dtls(
3239 p_api_version => p_api_version,
3240 p_init_msg_list => p_init_msg_list,
3241 x_return_status => x_return_status,
3242 x_msg_count => x_msg_count,
3243 x_msg_data => x_msg_data,
3244 p_mrdv_rec => l_mrdv_rec,
3245 x_mrdv_rec => x_mrdv_rec);
3246
3247 -- check return status
3248 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3249 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3250 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3251 raise OKC_API.G_EXCEPTION_ERROR;
3252 End If;
3253
3254 -- call AFTER user hook
3255 g_mrdv_rec := x_mrdv_rec;
3256
3257 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3258 p_package_name => g_pkg_name,
3259 p_procedure_name => l_api_name,
3260 p_before_after => 'A');
3261
3262 -- check return status of the user hook call
3263 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3264 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3265 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3266 raise OKC_API.G_EXCEPTION_ERROR;
3267 End If;
3268
3269 -- end activity
3270 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
3271 x_msg_data => x_msg_data);
3272 EXCEPTION
3273 when OKC_API.G_EXCEPTION_ERROR then
3274 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3275 p_api_name => l_api_name,
3276 p_pkg_name => g_pkg_name,
3277 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3278 x_msg_count => x_msg_count,
3279 x_msg_data => x_msg_data,
3280 p_api_type => g_api_type);
3281
3282 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3283 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3284 p_api_name => l_api_name,
3285 p_pkg_name => g_pkg_name,
3286 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3287 x_msg_count => x_msg_count,
3288 x_msg_data => x_msg_data,
3289 p_api_type => g_api_type);
3290
3291 when OTHERS then
3292 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3293 p_api_name => l_api_name,
3294 p_pkg_name => g_pkg_name,
3295 p_exc_name => 'OTHERS',
3296 x_msg_count => x_msg_count,
3297 x_msg_data => x_msg_data,
3298 p_api_type => g_api_type);
3299
3300 END Create_Masschange_Dtls;
3301
3302 PROCEDURE Create_Masschange_Dtls(
3303 p_api_version IN NUMBER,
3304 p_init_msg_list IN VARCHAR2 ,
3305 x_return_status OUT NOCOPY VARCHAR2,
3306 x_msg_count OUT NOCOPY NUMBER,
3307 x_msg_data OUT NOCOPY VARCHAR2,
3308 p_mrdv_tbl IN mrdv_tbl_type,
3309 x_mrdv_tbl OUT NOCOPY mrdv_tbl_type) IS
3310
3311 l_api_name CONSTANT VARCHAR2(30) := 'Create_Masschange_Dtls';
3312 l_api_version CONSTANT NUMBER := 1.0;
3313 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3314 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3315 i NUMBER;
3316 BEGIN
3317 -- call START_ACTIVITY to Create savepoint, check compatibility
3318 -- and initialize message list
3319 l_return_status := OKC_API.START_ACTIVITY(
3320 p_api_name => l_api_name,
3321 p_pkg_name => g_pkg_name,
3322 p_init_msg_list => p_init_msg_list,
3323 l_api_version => l_api_version,
3324 p_api_version => p_api_version,
3325 p_api_type => g_api_type,
3326 x_return_status => x_return_status);
3327
3328 -- check if activity started successfully
3329 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3330 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3331 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3332 raise OKC_API.G_EXCEPTION_ERROR;
3333 End If;
3334
3335 If (p_mrdv_tbl.COUNT > 0) Then
3336 i := p_mrdv_tbl.FIRST;
3337 LOOP
3338 -- call procedure in public API for a record
3339 OKC_OPER_INST_PUB.Create_Masschange_Dtls(
3340 p_api_version => p_api_version,
3341 p_init_msg_list => p_init_msg_list,
3342 x_return_status => x_return_status,
3343 x_msg_count => x_msg_count,
3344 x_msg_data => x_msg_data,
3345 p_mrdv_rec => p_mrdv_tbl(i),
3346 x_mrdv_rec => x_mrdv_tbl(i));
3347
3348 -- store the highest degree of error
3349 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3350 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3351 l_overall_status := x_return_status;
3352 End If;
3353 End If;
3354 EXIT WHEN (i = p_mrdv_tbl.LAST);
3355 i := p_mrdv_tbl.NEXT(i);
3356 END LOOP;
3357 -- return overall status
3358 x_return_status := l_overall_status;
3359 End If;
3360
3361 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3362 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3363 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3364 raise OKC_API.G_EXCEPTION_ERROR;
3365 End If;
3366
3367 -- end activity
3368 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
3369 x_msg_data => x_msg_data);
3370 EXCEPTION
3371 when OKC_API.G_EXCEPTION_ERROR then
3372 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3373 p_api_name => l_api_name,
3374 p_pkg_name => g_pkg_name,
3375 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3376 x_msg_count => x_msg_count,
3377 x_msg_data => x_msg_data,
3378 p_api_type => g_api_type);
3379
3380 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3381 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3382 p_api_name => l_api_name,
3383 p_pkg_name => g_pkg_name,
3384 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3385 x_msg_count => x_msg_count,
3386 x_msg_data => x_msg_data,
3387 p_api_type => g_api_type);
3388
3389 when OTHERS then
3390 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3391 p_api_name => l_api_name,
3392 p_pkg_name => g_pkg_name,
3393 p_exc_name => 'OTHERS',
3394 x_msg_count => x_msg_count,
3395 x_msg_data => x_msg_data,
3396 p_api_type => g_api_type);
3397
3398 END Create_Masschange_Dtls;
3399
3400 PROCEDURE Update_Masschange_Dtls(
3401 p_api_version IN NUMBER,
3402 p_init_msg_list IN VARCHAR2 ,
3403 x_return_status OUT NOCOPY VARCHAR2,
3404 x_msg_count OUT NOCOPY NUMBER,
3405 x_msg_data OUT NOCOPY VARCHAR2,
3406 p_mrdv_rec IN mrdv_rec_type,
3407 x_mrdv_rec OUT NOCOPY mrdv_rec_type) IS
3408
3409 l_mrdv_rec mrdv_rec_type;
3410 l_api_name CONSTANT VARCHAR2(30) := 'Update_Masschange_Dtls';
3411 l_api_version CONSTANT NUMBER := 1.0;
3412 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3413 BEGIN
3414 -- call START_ACTIVITY to Create savepoint, check compatibility
3415 -- and initialize message list
3416 l_return_status := OKC_API.START_ACTIVITY(
3417 p_api_name => l_api_name,
3418 p_pkg_name => g_pkg_name,
3419 p_init_msg_list => p_init_msg_list,
3420 l_api_version => l_api_version,
3421 p_api_version => p_api_version,
3422 p_api_type => g_api_type,
3423 x_return_status => x_return_status);
3424
3425 -- check if activity started successfully
3426 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3427 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3428 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3429 raise OKC_API.G_EXCEPTION_ERROR;
3430 End If;
3431
3432 -- call BEFORE user hook
3433 l_mrdv_rec := p_mrdv_rec;
3434 g_mrdv_rec := l_mrdv_rec;
3435
3436 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3437 p_package_name => g_pkg_name,
3438 p_procedure_name => l_api_name,
3439 p_before_after => 'B');
3440
3441 -- check return status of user hook call
3442 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3443 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3444 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3445 raise OKC_API.G_EXCEPTION_ERROR;
3446 End If;
3447
3448 -- get values back from user hook call
3449 l_mrdv_rec := g_mrdv_rec;
3450 l_mrdv_rec.id := p_mrdv_rec.id;
3451 l_mrdv_rec.object_version_number := p_mrdv_rec.object_version_number;
3452
3453 -- call procedure in complex API
3454 OKC_OPER_INST_PVT.Update_Masschange_Dtls(
3455 p_api_version => p_api_version,
3456 p_init_msg_list => p_init_msg_list,
3457 x_return_status => x_return_status,
3458 x_msg_count => x_msg_count,
3459 x_msg_data => x_msg_data,
3460 p_mrdv_rec => l_mrdv_rec,
3461 x_mrdv_rec => x_mrdv_rec);
3462
3463 -- check return status
3464 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3465 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3466 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3467 raise OKC_API.G_EXCEPTION_ERROR;
3468 End If;
3469
3470 -- call AFTER user hook
3471 g_mrdv_rec := x_mrdv_rec;
3472
3473 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3474 p_package_name => g_pkg_name,
3475 p_procedure_name => l_api_name,
3476 p_before_after => 'A');
3477
3478 -- check return status of the user hook call
3479 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3480 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3481 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3482 raise OKC_API.G_EXCEPTION_ERROR;
3483 End If;
3484
3485 -- end activity
3486 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
3487 x_msg_data => x_msg_data);
3488 EXCEPTION
3489 when OKC_API.G_EXCEPTION_ERROR then
3490 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3491 p_api_name => l_api_name,
3492 p_pkg_name => g_pkg_name,
3493 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3494 x_msg_count => x_msg_count,
3495 x_msg_data => x_msg_data,
3496 p_api_type => g_api_type);
3497
3498 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3499 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3500 p_api_name => l_api_name,
3501 p_pkg_name => g_pkg_name,
3502 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3503 x_msg_count => x_msg_count,
3504 x_msg_data => x_msg_data,
3505 p_api_type => g_api_type);
3506
3507 when OTHERS then
3508 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3509 p_api_name => l_api_name,
3510 p_pkg_name => g_pkg_name,
3511 p_exc_name => 'OTHERS',
3512 x_msg_count => x_msg_count,
3513 x_msg_data => x_msg_data,
3514 p_api_type => g_api_type);
3515
3516 END Update_Masschange_Dtls;
3517
3518 PROCEDURE Update_Masschange_Dtls(
3519 p_api_version IN NUMBER,
3520 p_init_msg_list IN VARCHAR2 ,
3521 x_return_status OUT NOCOPY VARCHAR2,
3522 x_msg_count OUT NOCOPY NUMBER,
3523 x_msg_data OUT NOCOPY VARCHAR2,
3524 p_mrdv_tbl IN mrdv_tbl_type,
3525 x_mrdv_tbl OUT NOCOPY mrdv_tbl_type) IS
3526
3527 l_api_name CONSTANT VARCHAR2(30) := 'Update_Masschange_Dtls';
3528 l_api_version CONSTANT NUMBER := 1.0;
3529 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3530 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3531 i NUMBER;
3532 BEGIN
3533 -- call START_ACTIVITY to Create savepoint, check compatibility
3534 -- and initialize message list
3535 l_return_status := OKC_API.START_ACTIVITY(
3536 p_api_name => l_api_name,
3537 p_pkg_name => g_pkg_name,
3538 p_init_msg_list => p_init_msg_list,
3539 l_api_version => l_api_version,
3540 p_api_version => p_api_version,
3541 p_api_type => g_api_type,
3542 x_return_status => x_return_status);
3543
3544 -- check if activity started successfully
3545 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3546 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3547 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3548 raise OKC_API.G_EXCEPTION_ERROR;
3549 End If;
3550
3551 If (p_mrdv_tbl.COUNT > 0) Then
3552 i := p_mrdv_tbl.FIRST;
3553 LOOP
3554 -- call procedure in complex API
3555 OKC_OPER_INST_PUB.Update_Masschange_Dtls(
3556 p_api_version => p_api_version,
3557 p_init_msg_list => p_init_msg_list,
3558 x_return_status => x_return_status,
3559 x_msg_count => x_msg_count,
3560 x_msg_data => x_msg_data,
3561 p_mrdv_rec => p_mrdv_tbl(i),
3562 x_mrdv_rec => x_mrdv_tbl(i));
3563
3564 -- store the highest degree of error
3565 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3566 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3567 l_overall_status := x_return_status;
3568 End If;
3569 End If;
3570 EXIT WHEN (i = p_mrdv_tbl.LAST);
3571 i := p_mrdv_tbl.NEXT(i);
3572 END LOOP;
3573 -- return overall status
3574 x_return_status := l_overall_status;
3575 End If;
3576
3577 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3578 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3579 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3580 raise OKC_API.G_EXCEPTION_ERROR;
3581 End If;
3582
3583 -- end activity
3584 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
3585 x_msg_data => x_msg_data);
3586 EXCEPTION
3587 when OKC_API.G_EXCEPTION_ERROR then
3588 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3589 p_api_name => l_api_name,
3590 p_pkg_name => g_pkg_name,
3591 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3592 x_msg_count => x_msg_count,
3593 x_msg_data => x_msg_data,
3594 p_api_type => g_api_type);
3595
3596 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3597 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3598 p_api_name => l_api_name,
3599 p_pkg_name => g_pkg_name,
3600 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3601 x_msg_count => x_msg_count,
3602 x_msg_data => x_msg_data,
3603 p_api_type => g_api_type);
3604
3605 when OTHERS then
3606 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3607 p_api_name => l_api_name,
3608 p_pkg_name => g_pkg_name,
3609 p_exc_name => 'OTHERS',
3610 x_msg_count => x_msg_count,
3611 x_msg_data => x_msg_data,
3612 p_api_type => g_api_type);
3613
3614 END Update_Masschange_Dtls;
3615
3616 PROCEDURE Delete_Masschange_Dtls(
3617 p_api_version IN NUMBER,
3618 p_init_msg_list IN VARCHAR2 ,
3619 x_return_status OUT NOCOPY VARCHAR2,
3620 x_msg_count OUT NOCOPY NUMBER,
3621 x_msg_data OUT NOCOPY VARCHAR2,
3622 p_mrdv_rec IN mrdv_rec_type) IS
3623
3624 l_mrdv_rec mrdv_rec_type;
3625 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Masschange_Dtls';
3626 l_api_version CONSTANT NUMBER := 1.0;
3627 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3628 BEGIN
3629 -- call START_ACTIVITY to Create savepoint, check compatibility
3630 -- and initialize message list
3631 l_return_status := OKC_API.START_ACTIVITY(
3632 p_api_name => l_api_name,
3633 p_pkg_name => g_pkg_name,
3634 p_init_msg_list => p_init_msg_list,
3635 l_api_version => l_api_version,
3636 p_api_version => p_api_version,
3637 p_api_type => g_api_type,
3638 x_return_status => x_return_status);
3639
3640 -- check if activity started successfully
3641 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3642 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3643 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3644 raise OKC_API.G_EXCEPTION_ERROR;
3645 End If;
3646
3647 -- call BEFORE user hook
3648 l_mrdv_rec := p_mrdv_rec;
3649 g_mrdv_rec := l_mrdv_rec;
3650
3651 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3652 p_package_name => g_pkg_name,
3653 p_procedure_name => l_api_name,
3654 p_before_after => 'B');
3655
3656 -- check return status of user hook call
3657 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3658 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3659 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3660 raise OKC_API.G_EXCEPTION_ERROR;
3661 End If;
3662
3663 -- get values back from user hook call
3664 l_mrdv_rec := g_mrdv_rec;
3665 l_mrdv_rec.id := p_mrdv_rec.id;
3666 l_mrdv_rec.object_version_number := p_mrdv_rec.object_version_number;
3667
3668 -- call procedure in complex API
3669 OKC_OPER_INST_PVT.Delete_Masschange_Dtls(
3670 p_api_version => p_api_version,
3671 p_init_msg_list => p_init_msg_list,
3672 x_return_status => x_return_status,
3673 x_msg_count => x_msg_count,
3674 x_msg_data => x_msg_data,
3675 p_mrdv_rec => l_mrdv_rec);
3676
3677 -- check return status
3678 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3679 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3680 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3681 raise OKC_API.G_EXCEPTION_ERROR;
3682 End If;
3683
3684 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3685 p_package_name => g_pkg_name,
3686 p_procedure_name => l_api_name,
3687 p_before_after => 'A');
3688
3689 -- check return status of the user hook call
3690 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3691 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3692 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3693 raise OKC_API.G_EXCEPTION_ERROR;
3694 End If;
3695
3696 -- end activity
3697 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
3698 x_msg_data => x_msg_data);
3699 EXCEPTION
3700 when OKC_API.G_EXCEPTION_ERROR then
3701 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3702 p_api_name => l_api_name,
3703 p_pkg_name => g_pkg_name,
3704 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3705 x_msg_count => x_msg_count,
3706 x_msg_data => x_msg_data,
3707 p_api_type => g_api_type);
3708
3709 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3710 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3711 p_api_name => l_api_name,
3712 p_pkg_name => g_pkg_name,
3713 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3714 x_msg_count => x_msg_count,
3715 x_msg_data => x_msg_data,
3716 p_api_type => g_api_type);
3717
3718 when OTHERS then
3719 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3720 p_api_name => l_api_name,
3721 p_pkg_name => g_pkg_name,
3722 p_exc_name => 'OTHERS',
3723 x_msg_count => x_msg_count,
3724 x_msg_data => x_msg_data,
3725 p_api_type => g_api_type);
3726
3727 END Delete_Masschange_Dtls;
3728
3729 PROCEDURE Delete_Masschange_Dtls(
3730 p_api_version IN NUMBER,
3731 p_init_msg_list IN VARCHAR2 ,
3732 x_return_status OUT NOCOPY VARCHAR2,
3733 x_msg_count OUT NOCOPY NUMBER,
3734 x_msg_data OUT NOCOPY VARCHAR2,
3735 p_mrdv_tbl IN mrdv_tbl_type) IS
3736
3737 l_api_name CONSTANT VARCHAR2(30) := 'Delete_Masschange_Dtls';
3738 l_api_version CONSTANT NUMBER := 1.0;
3739 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3740 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3741 i NUMBER;
3742 BEGIN
3743 -- call START_ACTIVITY to Create savepoint, check compatibility
3744 -- and initialize message list
3745 l_return_status := OKC_API.START_ACTIVITY(
3746 p_api_name => l_api_name,
3747 p_pkg_name => g_pkg_name,
3748 p_init_msg_list => p_init_msg_list,
3749 l_api_version => l_api_version,
3750 p_api_version => p_api_version,
3751 p_api_type => g_api_type,
3752 x_return_status => x_return_status);
3753
3754 -- check if activity started successfully
3755 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3756 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3757 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3758 raise OKC_API.G_EXCEPTION_ERROR;
3759 End If;
3760
3761 If (p_mrdv_tbl.COUNT > 0) Then
3762 i := p_mrdv_tbl.FIRST;
3763 LOOP
3764 -- call procedure in complex API
3765 OKC_OPER_INST_PUB.Delete_Masschange_Dtls(
3766 p_api_version => p_api_version,
3767 p_init_msg_list => p_init_msg_list,
3768 x_return_status => x_return_status,
3769 x_msg_count => x_msg_count,
3770 x_msg_data => x_msg_data,
3771 p_mrdv_rec => p_mrdv_tbl(i));
3772
3773 -- store the highest degree of error
3774 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3775 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3776 l_overall_status := x_return_status;
3777 End If;
3778 End If;
3779 EXIT WHEN (i = p_mrdv_tbl.LAST);
3780 i := p_mrdv_tbl.NEXT(i);
3781 END LOOP;
3782 -- return overall status
3783 x_return_status := l_overall_status;
3784 End If;
3785
3786 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3787 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3788 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3789 raise OKC_API.G_EXCEPTION_ERROR;
3790 End If;
3791
3792 -- end activity
3793 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
3794 x_msg_data => x_msg_data);
3795 EXCEPTION
3796 when OKC_API.G_EXCEPTION_ERROR then
3797 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3798 p_api_name => l_api_name,
3799 p_pkg_name => g_pkg_name,
3800 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3801 x_msg_count => x_msg_count,
3802 x_msg_data => x_msg_data,
3803 p_api_type => g_api_type);
3804
3805 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3806 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3807 p_api_name => l_api_name,
3808 p_pkg_name => g_pkg_name,
3809 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3810 x_msg_count => x_msg_count,
3811 x_msg_data => x_msg_data,
3812 p_api_type => g_api_type);
3813
3814 when OTHERS then
3815 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3816 p_api_name => l_api_name,
3817 p_pkg_name => g_pkg_name,
3818 p_exc_name => 'OTHERS',
3819 x_msg_count => x_msg_count,
3820 x_msg_data => x_msg_data,
3821 p_api_type => g_api_type);
3822
3823 END Delete_Masschange_Dtls;
3824
3825 PROCEDURE Lock_Masschange_Dtls(
3826 p_api_version IN NUMBER,
3827 p_init_msg_list IN VARCHAR2 ,
3828 x_return_status OUT NOCOPY VARCHAR2,
3829 x_msg_count OUT NOCOPY NUMBER,
3830 x_msg_data OUT NOCOPY VARCHAR2,
3831 p_mrdv_rec IN mrdv_rec_type) IS
3832
3833 l_mrdv_rec mrdv_rec_type;
3834 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Masschange_Dtls';
3835 l_api_version CONSTANT NUMBER := 1.0;
3836 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3837 BEGIN
3838 -- call START_ACTIVITY to Create savepoint, check compatibility
3839 -- and initialize message list
3840 l_return_status := OKC_API.START_ACTIVITY(
3841 p_api_name => l_api_name,
3842 p_pkg_name => g_pkg_name,
3843 p_init_msg_list => p_init_msg_list,
3844 l_api_version => l_api_version,
3845 p_api_version => p_api_version,
3846 p_api_type => g_api_type,
3847 x_return_status => x_return_status);
3848
3849 -- check if activity started successfully
3850 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3851 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3852 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3853 raise OKC_API.G_EXCEPTION_ERROR;
3854 End If;
3855
3856 -- call BEFORE user hook
3857 l_mrdv_rec := p_mrdv_rec;
3858 g_mrdv_rec := l_mrdv_rec;
3859
3860 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3861 p_package_name => g_pkg_name,
3862 p_procedure_name => l_api_name,
3863 p_before_after => 'B');
3864
3865 -- check return status of user hook call
3866 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3867 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3868 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3869 raise OKC_API.G_EXCEPTION_ERROR;
3870 End If;
3871
3872 -- get values back from user hook call
3873 l_mrdv_rec := g_mrdv_rec;
3874 l_mrdv_rec.id := p_mrdv_rec.id;
3875 l_mrdv_rec.object_version_number := p_mrdv_rec.object_version_number;
3876
3877 -- call procedure in complex API
3878 OKC_OPER_INST_PVT.Lock_Masschange_Dtls(
3879 p_api_version => p_api_version,
3880 p_init_msg_list => p_init_msg_list,
3881 x_return_status => x_return_status,
3882 x_msg_count => x_msg_count,
3883 x_msg_data => x_msg_data,
3884 p_mrdv_rec => l_mrdv_rec);
3885
3886 -- check return status
3887 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3888 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3889 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3890 raise OKC_API.G_EXCEPTION_ERROR;
3891 End If;
3892
3893 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3894 p_package_name => g_pkg_name,
3895 p_procedure_name => l_api_name,
3896 p_before_after => 'A');
3897
3898 -- check return status of the user hook call
3899 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3900 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3901 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3902 raise OKC_API.G_EXCEPTION_ERROR;
3903 End If;
3904
3905 -- end activity
3906 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
3907 x_msg_data => x_msg_data);
3908 EXCEPTION
3909 when OKC_API.G_EXCEPTION_ERROR then
3910 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3911 p_api_name => l_api_name,
3912 p_pkg_name => g_pkg_name,
3913 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3914 x_msg_count => x_msg_count,
3915 x_msg_data => x_msg_data,
3916 p_api_type => g_api_type);
3917
3918 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3919 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3920 p_api_name => l_api_name,
3921 p_pkg_name => g_pkg_name,
3922 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3923 x_msg_count => x_msg_count,
3924 x_msg_data => x_msg_data,
3925 p_api_type => g_api_type);
3926
3927 when OTHERS then
3928 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3929 p_api_name => l_api_name,
3930 p_pkg_name => g_pkg_name,
3931 p_exc_name => 'OTHERS',
3932 x_msg_count => x_msg_count,
3933 x_msg_data => x_msg_data,
3934 p_api_type => g_api_type);
3935
3936 END Lock_Masschange_Dtls;
3937
3938 PROCEDURE Lock_Masschange_Dtls(
3939 p_api_version IN NUMBER,
3940 p_init_msg_list IN VARCHAR2 ,
3941 x_return_status OUT NOCOPY VARCHAR2,
3942 x_msg_count OUT NOCOPY NUMBER,
3943 x_msg_data OUT NOCOPY VARCHAR2,
3944 p_mrdv_tbl IN mrdv_tbl_type) IS
3945
3946 l_api_name CONSTANT VARCHAR2(30) := 'Lock_Masschange_Dtls';
3947 l_api_version CONSTANT NUMBER := 1.0;
3948 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3949 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3950 i NUMBER;
3951 BEGIN
3952 -- call START_ACTIVITY to Create savepoint, check compatibility
3953 -- and initialize message list
3954 l_return_status := OKC_API.START_ACTIVITY(
3955 p_api_name => l_api_name,
3956 p_pkg_name => g_pkg_name,
3957 p_init_msg_list => p_init_msg_list,
3958 l_api_version => l_api_version,
3959 p_api_version => p_api_version,
3960 p_api_type => g_api_type,
3961 x_return_status => x_return_status);
3962
3963 -- check if activity started successfully
3964 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3965 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3966 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3967 raise OKC_API.G_EXCEPTION_ERROR;
3968 End If;
3969
3970 If (p_mrdv_tbl.COUNT > 0) Then
3971 i := p_mrdv_tbl.FIRST;
3972 LOOP
3973 -- call procedure in complex API
3974 OKC_OPER_INST_PUB.Lock_Masschange_Dtls(
3975 p_api_version => p_api_version,
3976 p_init_msg_list => p_init_msg_list,
3977 x_return_status => x_return_status,
3978 x_msg_count => x_msg_count,
3979 x_msg_data => x_msg_data,
3980 p_mrdv_rec => p_mrdv_tbl(i));
3981
3982 -- store the highest degree of error
3983 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3984 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3985 l_overall_status := x_return_status;
3986 End If;
3987 End If;
3988 EXIT WHEN (i = p_mrdv_tbl.LAST);
3989 i := p_mrdv_tbl.NEXT(i);
3990 END LOOP;
3991 -- return overall status
3992 x_return_status := l_overall_status;
3993 End If;
3994
3995 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3996 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3997 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3998 raise OKC_API.G_EXCEPTION_ERROR;
3999 End If;
4000
4001 -- end activity
4002 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
4003 x_msg_data => x_msg_data);
4004 EXCEPTION
4005 when OKC_API.G_EXCEPTION_ERROR then
4006 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4007 p_api_name => l_api_name,
4008 p_pkg_name => g_pkg_name,
4009 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4010 x_msg_count => x_msg_count,
4011 x_msg_data => x_msg_data,
4012 p_api_type => g_api_type);
4013
4014 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4015 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4016 p_api_name => l_api_name,
4017 p_pkg_name => g_pkg_name,
4018 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4019 x_msg_count => x_msg_count,
4020 x_msg_data => x_msg_data,
4021 p_api_type => g_api_type);
4022
4023 when OTHERS then
4024 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4025 p_api_name => l_api_name,
4026 p_pkg_name => g_pkg_name,
4027 p_exc_name => 'OTHERS',
4028 x_msg_count => x_msg_count,
4029 x_msg_data => x_msg_data,
4030 p_api_type => g_api_type);
4031
4032 END Lock_Masschange_Dtls;
4033
4034 PROCEDURE Validate_Masschange_Dtls(
4035 p_api_version IN NUMBER,
4036 p_init_msg_list IN VARCHAR2 ,
4037 x_return_status OUT NOCOPY VARCHAR2,
4038 x_msg_count OUT NOCOPY NUMBER,
4039 x_msg_data OUT NOCOPY VARCHAR2,
4040 p_mrdv_rec IN mrdv_rec_type) IS
4041
4042 l_mrdv_rec mrdv_rec_type;
4043 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Masschange_Dtls';
4044 l_api_version CONSTANT NUMBER := 1.0;
4045 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4046 BEGIN
4047 -- call START_ACTIVITY to Create savepoint, check compatibility
4048 -- and initialize message list
4049 l_return_status := OKC_API.START_ACTIVITY(
4050 p_api_name => l_api_name,
4051 p_pkg_name => g_pkg_name,
4052 p_init_msg_list => p_init_msg_list,
4053 l_api_version => l_api_version,
4054 p_api_version => p_api_version,
4055 p_api_type => g_api_type,
4056 x_return_status => x_return_status);
4057
4058 -- check if activity started successfully
4059 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4060 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4061 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4062 raise OKC_API.G_EXCEPTION_ERROR;
4063 End If;
4064
4065 -- call BEFORE user hook
4066 l_mrdv_rec := p_mrdv_rec;
4067 g_mrdv_rec := l_mrdv_rec;
4068
4069 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4070 p_package_name => g_pkg_name,
4071 p_procedure_name => l_api_name,
4072 p_before_after => 'B');
4073
4074 -- check return status of user hook call
4075 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4076 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4077 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4078 raise OKC_API.G_EXCEPTION_ERROR;
4079 End If;
4080
4081 -- get values back from user hook call
4082 l_mrdv_rec := g_mrdv_rec;
4083 l_mrdv_rec.id := p_mrdv_rec.id;
4084 l_mrdv_rec.object_version_number := p_mrdv_rec.object_version_number;
4085
4086 -- call procedure in complex API
4087 OKC_OPER_INST_PVT.Validate_Masschange_Dtls(
4088 p_api_version => p_api_version,
4089 p_init_msg_list => p_init_msg_list,
4090 x_return_status => x_return_status,
4091 x_msg_count => x_msg_count,
4092 x_msg_data => x_msg_data,
4093 p_mrdv_rec => l_mrdv_rec);
4094
4095 -- check return status
4096 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4097 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4098 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4099 raise OKC_API.G_EXCEPTION_ERROR;
4100 End If;
4101
4102 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4103 p_package_name => g_pkg_name,
4104 p_procedure_name => l_api_name,
4105 p_before_after => 'A');
4106
4107 -- check return status of the user hook call
4108 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4109 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4110 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4111 raise OKC_API.G_EXCEPTION_ERROR;
4112 End If;
4113
4114 -- end activity
4115 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
4116 x_msg_data => x_msg_data);
4117 EXCEPTION
4118 when OKC_API.G_EXCEPTION_ERROR then
4119 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4120 p_api_name => l_api_name,
4121 p_pkg_name => g_pkg_name,
4122 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4123 x_msg_count => x_msg_count,
4124 x_msg_data => x_msg_data,
4125 p_api_type => g_api_type);
4126
4127 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4128 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4129 p_api_name => l_api_name,
4130 p_pkg_name => g_pkg_name,
4131 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4132 x_msg_count => x_msg_count,
4133 x_msg_data => x_msg_data,
4134 p_api_type => g_api_type);
4135
4136 when OTHERS then
4137 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4138 p_api_name => l_api_name,
4139 p_pkg_name => g_pkg_name,
4140 p_exc_name => 'OTHERS',
4141 x_msg_count => x_msg_count,
4142 x_msg_data => x_msg_data,
4143 p_api_type => g_api_type);
4144
4145 END Validate_Masschange_Dtls;
4146
4147 PROCEDURE Validate_Masschange_Dtls(
4148 p_api_version IN NUMBER,
4149 p_init_msg_list IN VARCHAR2 ,
4150 x_return_status OUT NOCOPY VARCHAR2,
4151 x_msg_count OUT NOCOPY NUMBER,
4152 x_msg_data OUT NOCOPY VARCHAR2,
4153 p_mrdv_tbl IN mrdv_tbl_type) IS
4154
4155 l_api_name CONSTANT VARCHAR2(30) := 'Validate_Masschange_Dtls';
4156 l_api_version CONSTANT NUMBER := 1.0;
4157 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4158 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4159 i NUMBER;
4160 BEGIN
4161 -- call START_ACTIVITY to Create savepoint, check compatibility
4162 -- and initialize message list
4163 l_return_status := OKC_API.START_ACTIVITY(
4164 p_api_name => l_api_name,
4165 p_pkg_name => g_pkg_name,
4166 p_init_msg_list => p_init_msg_list,
4167 l_api_version => l_api_version,
4168 p_api_version => p_api_version,
4169 p_api_type => g_api_type,
4170 x_return_status => x_return_status);
4171
4172 -- check if activity started successfully
4173 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4174 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4175 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4176 raise OKC_API.G_EXCEPTION_ERROR;
4177 End If;
4178
4179 If (p_mrdv_tbl.COUNT > 0) Then
4180 i := p_mrdv_tbl.FIRST;
4181 LOOP
4182 -- call procedure in complex API
4183 OKC_OPER_INST_PUB.Validate_Masschange_Dtls(
4184 p_api_version => p_api_version,
4185 p_init_msg_list => p_init_msg_list,
4186 x_return_status => x_return_status,
4187 x_msg_count => x_msg_count,
4188 x_msg_data => x_msg_data,
4189 p_mrdv_rec => p_mrdv_tbl(i));
4190
4191 -- store the highest degree of error
4192 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
4193 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
4194 l_overall_status := x_return_status;
4195 End If;
4196 End If;
4197 EXIT WHEN (i = p_mrdv_tbl.LAST);
4198 i := p_mrdv_tbl.NEXT(i);
4199 END LOOP;
4200 -- return overall status
4201 x_return_status := l_overall_status;
4202 End If;
4203
4204 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4205 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4206 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4207 raise OKC_API.G_EXCEPTION_ERROR;
4208 End If;
4209
4210 -- end activity
4211 OKC_API.END_ACTIVITY(x_msg_count => x_msg_count,
4212 x_msg_data => x_msg_data);
4213 EXCEPTION
4214 when OKC_API.G_EXCEPTION_ERROR then
4215 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4216 p_api_name => l_api_name,
4217 p_pkg_name => g_pkg_name,
4218 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4219 x_msg_count => x_msg_count,
4220 x_msg_data => x_msg_data,
4221 p_api_type => g_api_type);
4222
4223 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4224 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4225 p_api_name => l_api_name,
4226 p_pkg_name => g_pkg_name,
4227 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4228 x_msg_count => x_msg_count,
4229 x_msg_data => x_msg_data,
4230 p_api_type => g_api_type);
4231
4232 when OTHERS then
4233 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4234 p_api_name => l_api_name,
4235 p_pkg_name => g_pkg_name,
4236 p_exc_name => 'OTHERS',
4237 x_msg_count => x_msg_count,
4238 x_msg_data => x_msg_data,
4239 p_api_type => g_api_type);
4240
4241 END Validate_Masschange_Dtls;
4242 END OKC_OPER_INST_PUB;