[Home] [Help]
PACKAGE BODY: APPS.OKC_CONTRACT_PUB
Source
1 PACKAGE BODY OKC_CONTRACT_PUB AS
2 /* $Header: OKCPCHRB.pls 120.3 2005/07/19 05:12:03 maanand noship $ */
3 l_debug VARCHAR2(1) := NVL(FND_PROFILE.VALUE('AFLOG_ENABLED'),'N');
4
5 -- subtype control_rec_type is okc_util.okc_control_rec_type;
6
7 g_api_type CONSTANT VARCHAR2(4) := '_PVT';
8
9 PROCEDURE create_contract_header(
10 p_api_version IN NUMBER,
11 p_init_msg_list IN VARCHAR2,
12 x_return_status OUT NOCOPY VARCHAR2,
13 x_msg_count OUT NOCOPY NUMBER,
14 x_msg_data OUT NOCOPY VARCHAR2,
15 p_chrv_rec IN chrv_rec_type,
16 x_chrv_rec OUT NOCOPY chrv_rec_type,
17 p_check_access IN VARCHAR2 ) IS
18
19 l_chrv_rec chrv_rec_type;
20 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_HEADER';
21 l_api_version CONSTANT NUMBER := 1.0;
22 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
23 l_modify_access BOOLEAN; --- for bug#2655281.
24 BEGIN
25 -- call START_ACTIVITY to create savepoint, check compatibility
26 -- and initialize message list
27 l_return_status := OKC_API.START_ACTIVITY(
28 p_api_name => l_api_name,
29 p_pkg_name => g_pkg_name,
30 p_init_msg_list => p_init_msg_list,
31 l_api_version => l_api_version,
32 p_api_version => p_api_version,
33 p_api_type => g_api_type,
34 x_return_status => x_return_status);
35
36 -- check if activity started successfully
37 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
38 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
39 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
40 raise OKC_API.G_EXCEPTION_ERROR;
41 End If;
42
43 -- call BEFORE user hook
44 l_chrv_rec := p_chrv_rec;
45 g_chrv_rec := l_chrv_rec;
46
47 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
48 p_package_name => g_pkg_name,
49 p_procedure_name => l_api_name,
50 p_before_after => 'B');
51
52 -- check return status of user hook call
53 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
54 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
55 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
56 raise OKC_API.G_EXCEPTION_ERROR;
57 End If;
58
59 -- get values back from user hook call
60 l_chrv_rec := g_chrv_rec;
61 l_chrv_rec.id := p_chrv_rec.id;
62 l_chrv_rec.object_version_number := p_chrv_rec.object_version_number;
63
64 -- bug 2684439
65 --l_modify_access willbe TRUE, if category has modify access.
66 If p_check_access = 'Y' Then
67 l_modify_access := OKC_UTIL.Create_K_Access(p_chrv_rec.scs_code);
68 Elsif p_check_access = 'N' Then
69 l_modify_access := TRUE;
70 End If;
71
72
73 --- Create a Contract If the Category have MODIFY(Define Category) ---Bug2655281.
74 IF l_modify_access THEN
75 -- call procedure in complex API
76 OKC_CONTRACT_PVT.create_contract_header(
77 p_api_version => p_api_version,
78 p_init_msg_list => p_init_msg_list,
79 x_return_status => x_return_status,
80 x_msg_count => x_msg_count,
81 x_msg_data => x_msg_data,
82 p_chrv_rec => l_chrv_rec,
83 x_chrv_rec => x_chrv_rec,
84 p_check_access => p_check_access);
85
86 ELSE
87 RAISE OKC_API.G_EXCEPTION_ERROR ;
88 END IF;
89
90 -- check return status
91 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
92 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
93 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
94 raise OKC_API.G_EXCEPTION_ERROR;
95 End If;
96
97 -- call AFTER user hook
98 g_chrv_rec := x_chrv_rec;
99
100 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
101 p_package_name => g_pkg_name,
102 p_procedure_name => l_api_name,
103 p_before_after => 'A');
104
105 -- check return status of the user hook call
106 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
107 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
108 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
109 raise OKC_API.G_EXCEPTION_ERROR;
110 End If;
111
112 -- end activity
113 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
114 x_msg_data => x_msg_data);
115 EXCEPTION
116 when OKC_API.G_EXCEPTION_ERROR then
117 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
118 p_api_name => l_api_name,
119 p_pkg_name => g_pkg_name,
120 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
121 x_msg_count => x_msg_count,
122 x_msg_data => x_msg_data,
123 p_api_type => g_api_type);
124
125 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
126 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
127 p_api_name => l_api_name,
128 p_pkg_name => g_pkg_name,
129 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
130 x_msg_count => x_msg_count,
131 x_msg_data => x_msg_data,
132 p_api_type => g_api_type);
133
134 when OTHERS then
135 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
136 p_api_name => l_api_name,
137 p_pkg_name => g_pkg_name,
138 p_exc_name => 'OTHERS',
139 x_msg_count => x_msg_count,
140 x_msg_data => x_msg_data,
141 p_api_type => g_api_type);
142
143 END create_contract_header;
144
145 PROCEDURE create_contract_header(
146 p_api_version IN NUMBER,
147 p_init_msg_list IN VARCHAR2 ,
148 x_return_status OUT NOCOPY VARCHAR2,
149 x_msg_count OUT NOCOPY NUMBER,
150 x_msg_data OUT NOCOPY VARCHAR2,
151 p_chrv_tbl IN chrv_tbl_type,
152 x_chrv_tbl OUT NOCOPY chrv_tbl_type,
153 p_check_access IN VARCHAR2 ) IS
154
155 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_HEADER';
156 l_api_version CONSTANT NUMBER := 1.0;
157 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
158 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
159 i NUMBER;
160 BEGIN
161 -- call START_ACTIVITY to create savepoint, check compatibility
162 -- and initialize message list
163 l_return_status := OKC_API.START_ACTIVITY(
164 p_api_name => l_api_name,
165 p_pkg_name => g_pkg_name,
166 p_init_msg_list => p_init_msg_list,
167 l_api_version => l_api_version,
168 p_api_version => p_api_version,
169 p_api_type => g_api_type,
170 x_return_status => x_return_status);
171
172 -- check if activity started successfully
173 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
174 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
175 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
176 raise OKC_API.G_EXCEPTION_ERROR;
177 End If;
178
179 If (p_chrv_tbl.COUNT > 0) Then
180 i := p_chrv_tbl.FIRST;
181 LOOP
182 -- call procedure in public API for a record
183 OKC_CONTRACT_PUB.create_contract_header(
184 p_api_version => p_api_version,
185 p_init_msg_list => p_init_msg_list,
186 x_return_status => x_return_status,
187 x_msg_count => x_msg_count,
188 x_msg_data => x_msg_data,
189 p_chrv_rec => p_chrv_tbl(i),
190 x_chrv_rec => x_chrv_tbl(i),
191 p_check_access => p_check_access);
192
193 -- store the highest degree of error
194 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
195 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
196 l_overall_status := x_return_status;
197 End If;
198 End If;
199 EXIT WHEN (i = p_chrv_tbl.LAST);
200 i := p_chrv_tbl.NEXT(i);
201 END LOOP;
202 -- return overall status
203 x_return_status := l_overall_status;
204 End If;
205
206 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
207 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
208 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
209 raise OKC_API.G_EXCEPTION_ERROR;
210 End If;
211
212 -- end activity
213 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
214 x_msg_data => x_msg_data);
215 EXCEPTION
216 when OKC_API.G_EXCEPTION_ERROR then
217 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
218 p_api_name => l_api_name,
219 p_pkg_name => g_pkg_name,
220 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
221 x_msg_count => x_msg_count,
222 x_msg_data => x_msg_data,
223 p_api_type => g_api_type);
224
225 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
226 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
227 p_api_name => l_api_name,
228 p_pkg_name => g_pkg_name,
229 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
230 x_msg_count => x_msg_count,
231 x_msg_data => x_msg_data,
232 p_api_type => g_api_type);
233
234 when OTHERS then
235 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
236 p_api_name => l_api_name,
237 p_pkg_name => g_pkg_name,
238 p_exc_name => 'OTHERS',
239 x_msg_count => x_msg_count,
240 x_msg_data => x_msg_data,
241 p_api_type => g_api_type);
242
243 END create_contract_header;
244
245 PROCEDURE update_contract_header(
246 p_api_version IN NUMBER,
247 p_init_msg_list IN VARCHAR2 ,
248 x_return_status OUT NOCOPY VARCHAR2,
249 x_msg_count OUT NOCOPY NUMBER,
250 x_msg_data OUT NOCOPY VARCHAR2,
251 p_restricted_update IN VARCHAR2 ,
252 p_chrv_rec IN chrv_rec_type,
253 x_chrv_rec OUT NOCOPY chrv_rec_type) IS
254
255 l_chrv_rec chrv_rec_type;
256 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_HEADER';
257 l_api_version CONSTANT NUMBER := 1.0;
258 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
259 BEGIN
260 -- call START_ACTIVITY to create savepoint, check compatibility
261 -- and initialize message list
262 l_return_status := OKC_API.START_ACTIVITY(
263 p_api_name => l_api_name,
264 p_pkg_name => g_pkg_name,
265 p_init_msg_list => p_init_msg_list,
266 l_api_version => l_api_version,
267 p_api_version => p_api_version,
268 p_api_type => g_api_type,
269 x_return_status => x_return_status);
270
271 -- check if activity started successfully
272 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
273 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
274 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
275 raise OKC_API.G_EXCEPTION_ERROR;
276 End If;
277
278 -- call BEFORE user hook
279 l_chrv_rec := p_chrv_rec;
280 g_chrv_rec := l_chrv_rec;
281
282 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
283 p_package_name => g_pkg_name,
284 p_procedure_name => l_api_name,
285 p_before_after => 'B');
286
287 -- check return status of user hook call
288 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
289 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
290 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
291 raise OKC_API.G_EXCEPTION_ERROR;
292 End If;
293
294 -- get values back from user hook call
295 l_chrv_rec := g_chrv_rec;
296 l_chrv_rec.id := p_chrv_rec.id;
297 l_chrv_rec.object_version_number := p_chrv_rec.object_version_number;
298
299 -- call procedure in complex API
300 OKC_CONTRACT_PVT.update_contract_header(
301 p_api_version => p_api_version,
302 p_init_msg_list => p_init_msg_list,
303 x_return_status => x_return_status,
304 x_msg_count => x_msg_count,
305 x_msg_data => x_msg_data,
306 p_restricted_update => p_restricted_update,
307 p_chrv_rec => l_chrv_rec,
308 x_chrv_rec => x_chrv_rec);
309
310 -- check return status
311 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
312 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
313 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
314 raise OKC_API.G_EXCEPTION_ERROR;
315 End If;
316
317 -- call AFTER user hook
318 g_chrv_rec := x_chrv_rec;
319
320 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
321 p_package_name => g_pkg_name,
322 p_procedure_name => l_api_name,
323 p_before_after => 'A');
324
325 -- check return status of the user hook call
326 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
327 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
328 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
329 raise OKC_API.G_EXCEPTION_ERROR;
330 End If;
331
332 -- end activity
333 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
334 x_msg_data => x_msg_data);
335 EXCEPTION
336 when OKC_API.G_EXCEPTION_ERROR then
337 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
338 p_api_name => l_api_name,
339 p_pkg_name => g_pkg_name,
340 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
341 x_msg_count => x_msg_count,
342 x_msg_data => x_msg_data,
343 p_api_type => g_api_type);
344
345 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
346 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
347 p_api_name => l_api_name,
348 p_pkg_name => g_pkg_name,
349 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
350 x_msg_count => x_msg_count,
351 x_msg_data => x_msg_data,
352 p_api_type => g_api_type);
353
354 when OTHERS then
355 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
356 p_api_name => l_api_name,
357 p_pkg_name => g_pkg_name,
358 p_exc_name => 'OTHERS',
359 x_msg_count => x_msg_count,
360 x_msg_data => x_msg_data,
361 p_api_type => g_api_type);
362
363 END update_contract_header;
364
365 PROCEDURE update_contract_header(
366 p_api_version IN NUMBER,
367 p_init_msg_list IN VARCHAR2 ,
368 x_return_status OUT NOCOPY VARCHAR2,
369 x_msg_count OUT NOCOPY NUMBER,
370 x_msg_data OUT NOCOPY VARCHAR2,
371 p_restricted_update IN VARCHAR2 ,
372 p_chrv_tbl IN chrv_tbl_type,
373 x_chrv_tbl OUT NOCOPY chrv_tbl_type) IS
374
375 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_HEADER';
376 l_api_version CONSTANT NUMBER := 1.0;
377 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
378 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
379 i NUMBER;
380 BEGIN
381 -- call START_ACTIVITY to create savepoint, check compatibility
382 -- and initialize message list
383 l_return_status := OKC_API.START_ACTIVITY(
384 p_api_name => l_api_name,
385 p_pkg_name => g_pkg_name,
386 p_init_msg_list => p_init_msg_list,
387 l_api_version => l_api_version,
388 p_api_version => p_api_version,
389 p_api_type => g_api_type,
390 x_return_status => x_return_status);
391
392 -- check if activity started successfully
393 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
394 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
395 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
396 raise OKC_API.G_EXCEPTION_ERROR;
397 End If;
398
399 If (p_chrv_tbl.COUNT > 0) Then
400 i := p_chrv_tbl.FIRST;
401 LOOP
402 -- call procedure in complex API
403 OKC_CONTRACT_PUB.update_contract_header(
404 p_api_version => p_api_version,
405 p_init_msg_list => p_init_msg_list,
406 x_return_status => x_return_status,
407 x_msg_count => x_msg_count,
408 x_msg_data => x_msg_data,
409 p_restricted_update => p_restricted_update,
410 p_chrv_rec => p_chrv_tbl(i),
411 x_chrv_rec => x_chrv_tbl(i));
412
413 -- store the highest degree of error
414 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
415 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
416 l_overall_status := x_return_status;
417 End If;
418 End If;
419 EXIT WHEN (i = p_chrv_tbl.LAST);
420 i := p_chrv_tbl.NEXT(i);
421 END LOOP;
422 -- return overall status
423 x_return_status := l_overall_status;
424 End If;
425
426 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
427 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
428 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
429 raise OKC_API.G_EXCEPTION_ERROR;
430 End If;
431
432 -- end activity
433 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
434 x_msg_data => x_msg_data);
435 EXCEPTION
436 when OKC_API.G_EXCEPTION_ERROR then
437 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
438 p_api_name => l_api_name,
439 p_pkg_name => g_pkg_name,
440 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
441 x_msg_count => x_msg_count,
442 x_msg_data => x_msg_data,
443 p_api_type => g_api_type);
444
445 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
446 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
447 p_api_name => l_api_name,
448 p_pkg_name => g_pkg_name,
449 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
450 x_msg_count => x_msg_count,
451 x_msg_data => x_msg_data,
452 p_api_type => g_api_type);
453
454 when OTHERS then
455 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
456 p_api_name => l_api_name,
457 p_pkg_name => g_pkg_name,
458 p_exc_name => 'OTHERS',
459 x_msg_count => x_msg_count,
460 x_msg_data => x_msg_data,
461 p_api_type => g_api_type);
462
463 END update_contract_header;
464
465 PROCEDURE update_contract_header(
466 p_api_version IN NUMBER,
467 p_init_msg_list IN VARCHAR2 ,
468 x_return_status OUT NOCOPY VARCHAR2,
469 x_msg_count OUT NOCOPY NUMBER,
470 x_msg_data OUT NOCOPY VARCHAR2,
471 p_restricted_update IN VARCHAR2 ,
472 p_chrv_rec IN chrv_rec_type,
473 p_control_rec IN control_rec_type,
474 x_chrv_rec OUT NOCOPY chrv_rec_type) IS
475
476 l_chrv_rec chrv_rec_type;
477 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_HEADER';
478 l_api_version CONSTANT NUMBER := 1.0;
479 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
480 BEGIN
481 -- call START_ACTIVITY to create savepoint, check compatibility
482 -- and initialize message list
483 l_return_status := OKC_API.START_ACTIVITY(
484 p_api_name => l_api_name,
485 p_pkg_name => g_pkg_name,
486 p_init_msg_list => p_init_msg_list,
487 l_api_version => l_api_version,
488 p_api_version => p_api_version,
489 p_api_type => g_api_type,
490 x_return_status => x_return_status);
491
492 -- check if activity started successfully
493 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
494 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
495 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
496 raise OKC_API.G_EXCEPTION_ERROR;
497 End If;
498
499 -- call BEFORE user hook
500 l_chrv_rec := p_chrv_rec;
501 g_chrv_rec := l_chrv_rec;
502
503 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
504 p_package_name => g_pkg_name,
505 p_procedure_name => l_api_name,
506 p_before_after => 'B');
507
508 -- check return status of user hook call
509 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
510 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
511 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
512 raise OKC_API.G_EXCEPTION_ERROR;
513 End If;
514
515 -- get values back from user hook call
516 l_chrv_rec := g_chrv_rec;
517 l_chrv_rec.id := p_chrv_rec.id;
518 l_chrv_rec.object_version_number := p_chrv_rec.object_version_number;
519
520 -- call procedure in complex API
521 OKC_CONTRACT_PVT.update_contract_header(
522 p_api_version => p_api_version,
523 p_init_msg_list => p_init_msg_list,
524 x_return_status => x_return_status,
525 x_msg_count => x_msg_count,
526 x_msg_data => x_msg_data,
527 p_restricted_update => p_restricted_update,
528 p_chrv_rec => l_chrv_rec,
529 p_control_rec => p_control_rec,
530 x_chrv_rec => x_chrv_rec);
531
532 -- check return status
533 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
534 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
535 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
536 raise OKC_API.G_EXCEPTION_ERROR;
537 End If;
538
539 -- call AFTER user hook
540 g_chrv_rec := x_chrv_rec;
541
542 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
543 p_package_name => g_pkg_name,
544 p_procedure_name => l_api_name,
545 p_before_after => 'A');
546
547 -- check return status of the user hook call
548 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
549 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
550 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
551 raise OKC_API.G_EXCEPTION_ERROR;
552 End If;
553
554 -- end activity
555 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
556 x_msg_data => x_msg_data);
557 EXCEPTION
558 when OKC_API.G_EXCEPTION_ERROR then
559 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
560 p_api_name => l_api_name,
561 p_pkg_name => g_pkg_name,
562 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
563 x_msg_count => x_msg_count,
564 x_msg_data => x_msg_data,
565 p_api_type => g_api_type);
566
567 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
568 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
569 p_api_name => l_api_name,
570 p_pkg_name => g_pkg_name,
571 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
572 x_msg_count => x_msg_count,
573 x_msg_data => x_msg_data,
574 p_api_type => g_api_type);
575
576 when OTHERS then
577 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
578 p_api_name => l_api_name,
579 p_pkg_name => g_pkg_name,
580 p_exc_name => 'OTHERS',
581 x_msg_count => x_msg_count,
582 x_msg_data => x_msg_data,
583 p_api_type => g_api_type);
584
585 END update_contract_header;
586
587 PROCEDURE update_contract_header(
588 p_api_version IN NUMBER,
589 p_init_msg_list IN VARCHAR2 ,
590 x_return_status OUT NOCOPY VARCHAR2,
591 x_msg_count OUT NOCOPY NUMBER,
592 x_msg_data OUT NOCOPY VARCHAR2,
593 p_restricted_update IN VARCHAR2 ,
594 p_chrv_tbl IN chrv_tbl_type,
595 p_control_rec IN control_rec_type,
596 x_chrv_tbl OUT NOCOPY chrv_tbl_type) IS
597
598 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_HEADER';
599 l_api_version CONSTANT NUMBER := 1.0;
600 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
601 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
602 i NUMBER;
603 BEGIN
604 -- call START_ACTIVITY to create savepoint, check compatibility
605 -- and initialize message list
606 l_return_status := OKC_API.START_ACTIVITY(
607 p_api_name => l_api_name,
608 p_pkg_name => g_pkg_name,
609 p_init_msg_list => p_init_msg_list,
610 l_api_version => l_api_version,
611 p_api_version => p_api_version,
612 p_api_type => g_api_type,
613 x_return_status => x_return_status);
614
615 -- check if activity started successfully
616 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
617 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
618 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
619 raise OKC_API.G_EXCEPTION_ERROR;
620 End If;
621
622 If (p_chrv_tbl.COUNT > 0) Then
623 i := p_chrv_tbl.FIRST;
624 LOOP
625 -- call procedure in complex API
626 OKC_CONTRACT_PUB.update_contract_header(
627 p_api_version => p_api_version,
628 p_init_msg_list => p_init_msg_list,
629 x_return_status => x_return_status,
630 x_msg_count => x_msg_count,
631 x_msg_data => x_msg_data,
632 p_restricted_update => p_restricted_update,
633 p_chrv_rec => p_chrv_tbl(i),
634 p_control_rec => p_control_rec,
635 x_chrv_rec => x_chrv_tbl(i));
636
637 -- store the highest degree of error
638 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
639 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
640 l_overall_status := x_return_status;
641 End If;
642 End If;
643 EXIT WHEN (i = p_chrv_tbl.LAST);
644 i := p_chrv_tbl.NEXT(i);
645 END LOOP;
646 -- return overall status
647 x_return_status := l_overall_status;
648 End If;
649
650 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
651 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
652 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
653 raise OKC_API.G_EXCEPTION_ERROR;
654 End If;
655
656 -- end activity
657 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
658 x_msg_data => x_msg_data);
659 EXCEPTION
660 when OKC_API.G_EXCEPTION_ERROR then
661 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
662 p_api_name => l_api_name,
663 p_pkg_name => g_pkg_name,
664 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
665 x_msg_count => x_msg_count,
666 x_msg_data => x_msg_data,
667 p_api_type => g_api_type);
668
669 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
670 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
671 p_api_name => l_api_name,
672 p_pkg_name => g_pkg_name,
673 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
674 x_msg_count => x_msg_count,
675 x_msg_data => x_msg_data,
676 p_api_type => g_api_type);
677
678 when OTHERS then
679 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
680 p_api_name => l_api_name,
681 p_pkg_name => g_pkg_name,
682 p_exc_name => 'OTHERS',
683 x_msg_count => x_msg_count,
684 x_msg_data => x_msg_data,
685 p_api_type => g_api_type);
686
687 END update_contract_header;
688
689 PROCEDURE delete_contract_header(
690 p_api_version IN NUMBER,
691 p_init_msg_list IN VARCHAR2 ,
692 x_return_status OUT NOCOPY VARCHAR2,
693 x_msg_count OUT NOCOPY NUMBER,
694 x_msg_data OUT NOCOPY VARCHAR2,
695 p_chrv_rec IN chrv_rec_type) IS
696
697 l_chrv_rec chrv_rec_type;
698 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_HEADER';
699 l_api_version CONSTANT NUMBER := 1.0;
700 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
701 BEGIN
702 -- call START_ACTIVITY to create savepoint, check compatibility
703 -- and initialize message list
704 l_return_status := OKC_API.START_ACTIVITY(
705 p_api_name => l_api_name,
706 p_pkg_name => g_pkg_name,
707 p_init_msg_list => p_init_msg_list,
708 l_api_version => l_api_version,
709 p_api_version => p_api_version,
710 p_api_type => g_api_type,
711 x_return_status => x_return_status);
712
713 -- check if activity started successfully
714 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
715 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
716 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
717 raise OKC_API.G_EXCEPTION_ERROR;
718 End If;
719
720 -- call BEFORE user hook
721 l_chrv_rec := p_chrv_rec;
722 g_chrv_rec := l_chrv_rec;
723
724 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
725 p_package_name => g_pkg_name,
726 p_procedure_name => l_api_name,
727 p_before_after => 'B');
728
729 -- check return status of user hook call
730 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
731 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
732 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
733 raise OKC_API.G_EXCEPTION_ERROR;
734 End If;
735
736 -- get values back from user hook call
737 l_chrv_rec := g_chrv_rec;
738 l_chrv_rec.id := p_chrv_rec.id;
739 l_chrv_rec.object_version_number := p_chrv_rec.object_version_number;
740
741 -- call procedure in complex API
742 OKC_CONTRACT_PVT.delete_contract_header(
743 p_api_version => p_api_version,
744 p_init_msg_list => p_init_msg_list,
745 x_return_status => x_return_status,
746 x_msg_count => x_msg_count,
747 x_msg_data => x_msg_data,
748 p_chrv_rec => l_chrv_rec);
749
750 -- check return status
751 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
752 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
753 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
754 raise OKC_API.G_EXCEPTION_ERROR;
755 End If;
756
757 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
758 p_package_name => g_pkg_name,
759 p_procedure_name => l_api_name,
760 p_before_after => 'A');
761
762 -- check return status of the user hook call
763 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
764 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
765 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
766 raise OKC_API.G_EXCEPTION_ERROR;
767 End If;
768
769 -- end activity
770 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
771 x_msg_data => x_msg_data);
772 EXCEPTION
773 when OKC_API.G_EXCEPTION_ERROR then
774 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
775 p_api_name => l_api_name,
776 p_pkg_name => g_pkg_name,
777 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
778 x_msg_count => x_msg_count,
779 x_msg_data => x_msg_data,
780 p_api_type => g_api_type);
781
782 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
783 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
784 p_api_name => l_api_name,
785 p_pkg_name => g_pkg_name,
786 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
787 x_msg_count => x_msg_count,
788 x_msg_data => x_msg_data,
789 p_api_type => g_api_type);
790
791 when OTHERS then
792 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
793 p_api_name => l_api_name,
794 p_pkg_name => g_pkg_name,
795 p_exc_name => 'OTHERS',
796 x_msg_count => x_msg_count,
797 x_msg_data => x_msg_data,
798 p_api_type => g_api_type);
799
800 END delete_contract_header;
801
802 PROCEDURE delete_contract_header(
803 p_api_version IN NUMBER,
804 p_init_msg_list IN VARCHAR2 ,
805 x_return_status OUT NOCOPY VARCHAR2,
806 x_msg_count OUT NOCOPY NUMBER,
807 x_msg_data OUT NOCOPY VARCHAR2,
808 p_chrv_tbl IN chrv_tbl_type) IS
809
810 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_HEADER';
811 l_api_version CONSTANT NUMBER := 1.0;
812 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
813 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
814 i NUMBER;
815 BEGIN
816 -- call START_ACTIVITY to create savepoint, check compatibility
817 -- and initialize message list
818 l_return_status := OKC_API.START_ACTIVITY(
819 p_api_name => l_api_name,
820 p_pkg_name => g_pkg_name,
821 p_init_msg_list => p_init_msg_list,
822 l_api_version => l_api_version,
823 p_api_version => p_api_version,
824 p_api_type => g_api_type,
825 x_return_status => x_return_status);
826
827 -- check if activity started successfully
828 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
829 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
830 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
831 raise OKC_API.G_EXCEPTION_ERROR;
832 End If;
833
834 If (p_chrv_tbl.COUNT > 0) Then
835 i := p_chrv_tbl.FIRST;
836 LOOP
837 -- call procedure in complex API
838 OKC_CONTRACT_PUB.delete_contract_header(
839 p_api_version => p_api_version,
840 p_init_msg_list => p_init_msg_list,
841 x_return_status => x_return_status,
842 x_msg_count => x_msg_count,
843 x_msg_data => x_msg_data,
844 p_chrv_rec => p_chrv_tbl(i));
845
846 -- store the highest degree of error
847 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
848 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
849 l_overall_status := x_return_status;
850 End If;
851 End If;
852 EXIT WHEN (i = p_chrv_tbl.LAST);
853 i := p_chrv_tbl.NEXT(i);
854 END LOOP;
855 -- return overall status
856 x_return_status := l_overall_status;
857 End If;
858
859 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
860 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
861 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
862 raise OKC_API.G_EXCEPTION_ERROR;
863 End If;
864
865 -- end activity
866 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
867 x_msg_data => x_msg_data);
868 EXCEPTION
869 when OKC_API.G_EXCEPTION_ERROR then
870 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
871 p_api_name => l_api_name,
872 p_pkg_name => g_pkg_name,
873 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
874 x_msg_count => x_msg_count,
875 x_msg_data => x_msg_data,
876 p_api_type => g_api_type);
877
878 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
879 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
880 p_api_name => l_api_name,
881 p_pkg_name => g_pkg_name,
882 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
883 x_msg_count => x_msg_count,
884 x_msg_data => x_msg_data,
885 p_api_type => g_api_type);
886
887 when OTHERS then
888 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
889 p_api_name => l_api_name,
890 p_pkg_name => g_pkg_name,
891 p_exc_name => 'OTHERS',
892 x_msg_count => x_msg_count,
893 x_msg_data => x_msg_data,
894 p_api_type => g_api_type);
895
896 END delete_contract_header;
897
898 PROCEDURE lock_contract_header(
899 p_api_version IN NUMBER,
900 p_init_msg_list IN VARCHAR2 ,
901 x_return_status OUT NOCOPY VARCHAR2,
902 x_msg_count OUT NOCOPY NUMBER,
903 x_msg_data OUT NOCOPY VARCHAR2,
904 p_chrv_rec IN chrv_rec_type) IS
905
906 l_chrv_rec chrv_rec_type;
907 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_HEADER';
908 l_api_version CONSTANT NUMBER := 1.0;
909 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
910 BEGIN
911 -- call START_ACTIVITY to create savepoint, check compatibility
912 -- and initialize message list
913 l_return_status := OKC_API.START_ACTIVITY(
914 p_api_name => l_api_name,
915 p_pkg_name => g_pkg_name,
916 p_init_msg_list => p_init_msg_list,
917 l_api_version => l_api_version,
918 p_api_version => p_api_version,
919 p_api_type => g_api_type,
920 x_return_status => x_return_status);
921
922 -- check if activity started successfully
923 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
924 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
925 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
926 raise OKC_API.G_EXCEPTION_ERROR;
927 End If;
928
929 -- call BEFORE user hook
930 l_chrv_rec := p_chrv_rec;
931 g_chrv_rec := l_chrv_rec;
932
933 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
934 p_package_name => g_pkg_name,
935 p_procedure_name => l_api_name,
936 p_before_after => 'B');
937
938 -- check return status of user hook call
939 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
940 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
941 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
942 raise OKC_API.G_EXCEPTION_ERROR;
943 End If;
944
945 -- get values back from user hook call
946 l_chrv_rec := g_chrv_rec;
947 l_chrv_rec.id := p_chrv_rec.id;
948 l_chrv_rec.object_version_number := p_chrv_rec.object_version_number;
949
950 -- call procedure in complex API
951 OKC_CONTRACT_PVT.lock_contract_header(
952 p_api_version => p_api_version,
953 p_init_msg_list => p_init_msg_list,
954 x_return_status => x_return_status,
955 x_msg_count => x_msg_count,
956 x_msg_data => x_msg_data,
957 p_chrv_rec => l_chrv_rec);
958
959 -- check return status
960 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
961 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
962 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
963 raise OKC_API.G_EXCEPTION_ERROR;
964 End If;
965
966 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
967 p_package_name => g_pkg_name,
968 p_procedure_name => l_api_name,
969 p_before_after => 'A');
970
971 -- check return status of the user hook call
972 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
973 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
974 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
975 raise OKC_API.G_EXCEPTION_ERROR;
976 End If;
977
978 -- end activity
979 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
980 x_msg_data => x_msg_data);
981 EXCEPTION
982 when OKC_API.G_EXCEPTION_ERROR then
983 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
984 p_api_name => l_api_name,
985 p_pkg_name => g_pkg_name,
986 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
987 x_msg_count => x_msg_count,
988 x_msg_data => x_msg_data,
989 p_api_type => g_api_type);
990
991 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
992 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
993 p_api_name => l_api_name,
994 p_pkg_name => g_pkg_name,
995 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
996 x_msg_count => x_msg_count,
997 x_msg_data => x_msg_data,
998 p_api_type => g_api_type);
999
1000 when OTHERS then
1001 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1002 p_api_name => l_api_name,
1003 p_pkg_name => g_pkg_name,
1004 p_exc_name => 'OTHERS',
1005 x_msg_count => x_msg_count,
1006 x_msg_data => x_msg_data,
1007 p_api_type => g_api_type);
1008
1009 END lock_contract_header;
1010
1011 PROCEDURE lock_contract_header(
1012 p_api_version IN NUMBER,
1013 p_init_msg_list IN VARCHAR2 ,
1014 x_return_status OUT NOCOPY VARCHAR2,
1015 x_msg_count OUT NOCOPY NUMBER,
1016 x_msg_data OUT NOCOPY VARCHAR2,
1017 p_chrv_tbl IN chrv_tbl_type) IS
1018
1019 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_HEADER';
1020 l_api_version CONSTANT NUMBER := 1.0;
1021 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1022 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1023 i NUMBER;
1024 BEGIN
1025 -- call START_ACTIVITY to create savepoint, check compatibility
1026 -- and initialize message list
1027 l_return_status := OKC_API.START_ACTIVITY(
1028 p_api_name => l_api_name,
1029 p_pkg_name => g_pkg_name,
1030 p_init_msg_list => p_init_msg_list,
1031 l_api_version => l_api_version,
1032 p_api_version => p_api_version,
1033 p_api_type => g_api_type,
1034 x_return_status => x_return_status);
1035
1036 -- check if activity started successfully
1037 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1038 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1039 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1040 raise OKC_API.G_EXCEPTION_ERROR;
1041 End If;
1042
1043 If (p_chrv_tbl.COUNT > 0) Then
1044 i := p_chrv_tbl.FIRST;
1045 LOOP
1046 -- call procedure in complex API
1047 OKC_CONTRACT_PUB.lock_contract_header(
1048 p_api_version => p_api_version,
1049 p_init_msg_list => p_init_msg_list,
1050 x_return_status => x_return_status,
1051 x_msg_count => x_msg_count,
1052 x_msg_data => x_msg_data,
1053 p_chrv_rec => p_chrv_tbl(i));
1054
1055 -- store the highest degree of error
1056 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1057 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1058 l_overall_status := x_return_status;
1059 End If;
1060 End If;
1061 EXIT WHEN (i = p_chrv_tbl.LAST);
1062 i := p_chrv_tbl.NEXT(i);
1063 END LOOP;
1064 -- return overall status
1065 x_return_status := l_overall_status;
1066 End If;
1067
1068 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1069 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1070 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1071 raise OKC_API.G_EXCEPTION_ERROR;
1072 End If;
1073
1074 -- end activity
1075 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1076 x_msg_data => x_msg_data);
1077 EXCEPTION
1078 when OKC_API.G_EXCEPTION_ERROR then
1079 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1080 p_api_name => l_api_name,
1081 p_pkg_name => g_pkg_name,
1082 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1083 x_msg_count => x_msg_count,
1084 x_msg_data => x_msg_data,
1085 p_api_type => g_api_type);
1086
1087 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1088 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1089 p_api_name => l_api_name,
1090 p_pkg_name => g_pkg_name,
1091 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1092 x_msg_count => x_msg_count,
1093 x_msg_data => x_msg_data,
1094 p_api_type => g_api_type);
1095
1096 when OTHERS then
1097 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1098 p_api_name => l_api_name,
1099 p_pkg_name => g_pkg_name,
1100 p_exc_name => 'OTHERS',
1101 x_msg_count => x_msg_count,
1102 x_msg_data => x_msg_data,
1103 p_api_type => g_api_type);
1104
1105 END lock_contract_header;
1106
1107 PROCEDURE validate_contract_header(
1108 p_api_version IN NUMBER,
1109 p_init_msg_list IN VARCHAR2 ,
1110 x_return_status OUT NOCOPY VARCHAR2,
1111 x_msg_count OUT NOCOPY NUMBER,
1112 x_msg_data OUT NOCOPY VARCHAR2,
1113 p_chrv_rec IN chrv_rec_type) IS
1114
1115 l_chrv_rec chrv_rec_type;
1116 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_HEADER';
1117 l_api_version CONSTANT NUMBER := 1.0;
1118 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1119 BEGIN
1120 -- call START_ACTIVITY to create savepoint, check compatibility
1121 -- and initialize message list
1122 l_return_status := OKC_API.START_ACTIVITY(
1123 p_api_name => l_api_name,
1124 p_pkg_name => g_pkg_name,
1125 p_init_msg_list => p_init_msg_list,
1126 l_api_version => l_api_version,
1127 p_api_version => p_api_version,
1128 p_api_type => g_api_type,
1129 x_return_status => x_return_status);
1130
1131 -- check if activity started successfully
1132 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1133 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1134 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1135 raise OKC_API.G_EXCEPTION_ERROR;
1136 End If;
1137
1138 -- call BEFORE user hook
1139 l_chrv_rec := p_chrv_rec;
1140 g_chrv_rec := l_chrv_rec;
1141
1142 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1143 p_package_name => g_pkg_name,
1144 p_procedure_name => l_api_name,
1145 p_before_after => 'B');
1146
1147 -- check return status of user hook call
1148 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1149 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1150 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1151 raise OKC_API.G_EXCEPTION_ERROR;
1152 End If;
1153
1154 -- get values back from user hook call
1155 l_chrv_rec := g_chrv_rec;
1156 l_chrv_rec.id := p_chrv_rec.id;
1157 l_chrv_rec.object_version_number := p_chrv_rec.object_version_number;
1158
1159 -- call procedure in complex API
1160 OKC_CONTRACT_PVT.validate_contract_header(
1161 p_api_version => p_api_version,
1162 p_init_msg_list => p_init_msg_list,
1163 x_return_status => x_return_status,
1164 x_msg_count => x_msg_count,
1165 x_msg_data => x_msg_data,
1166 p_chrv_rec => l_chrv_rec);
1167
1168 -- check return status
1169 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1170 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1171 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1172 raise OKC_API.G_EXCEPTION_ERROR;
1173 End If;
1174
1175 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1176 p_package_name => g_pkg_name,
1177 p_procedure_name => l_api_name,
1178 p_before_after => 'A');
1179
1180 -- check return status of the user hook call
1181 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1182 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1183 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1184 raise OKC_API.G_EXCEPTION_ERROR;
1185 End If;
1186
1187 -- end activity
1188 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1189 x_msg_data => x_msg_data);
1190 EXCEPTION
1191 when OKC_API.G_EXCEPTION_ERROR then
1192 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1193 p_api_name => l_api_name,
1194 p_pkg_name => g_pkg_name,
1195 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1196 x_msg_count => x_msg_count,
1197 x_msg_data => x_msg_data,
1198 p_api_type => g_api_type);
1199
1200 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1201 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1202 p_api_name => l_api_name,
1203 p_pkg_name => g_pkg_name,
1204 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1205 x_msg_count => x_msg_count,
1206 x_msg_data => x_msg_data,
1207 p_api_type => g_api_type);
1208
1209 when OTHERS then
1210 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1211 p_api_name => l_api_name,
1212 p_pkg_name => g_pkg_name,
1213 p_exc_name => 'OTHERS',
1214 x_msg_count => x_msg_count,
1215 x_msg_data => x_msg_data,
1216 p_api_type => g_api_type);
1217
1218 END validate_contract_header;
1219
1220 PROCEDURE validate_contract_header(
1221 p_api_version IN NUMBER,
1222 p_init_msg_list IN VARCHAR2 ,
1223 x_return_status OUT NOCOPY VARCHAR2,
1224 x_msg_count OUT NOCOPY NUMBER,
1225 x_msg_data OUT NOCOPY VARCHAR2,
1226 p_chrv_tbl IN chrv_tbl_type) IS
1227
1228 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_HEADER';
1229 l_api_version CONSTANT NUMBER := 1.0;
1230 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1231 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1232 i NUMBER;
1233 BEGIN
1234 -- call START_ACTIVITY to create savepoint, check compatibility
1235 -- and initialize message list
1236 l_return_status := OKC_API.START_ACTIVITY(
1237 p_api_name => l_api_name,
1238 p_pkg_name => g_pkg_name,
1239 p_init_msg_list => p_init_msg_list,
1240 l_api_version => l_api_version,
1241 p_api_version => p_api_version,
1242 p_api_type => g_api_type,
1243 x_return_status => x_return_status);
1244
1245 -- check if activity started successfully
1246 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1247 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1248 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1249 raise OKC_API.G_EXCEPTION_ERROR;
1250 End If;
1251
1252 If (p_chrv_tbl.COUNT > 0) Then
1253 i := p_chrv_tbl.FIRST;
1254 LOOP
1255 -- call procedure in complex API
1256 OKC_CONTRACT_PUB.validate_contract_header(
1257 p_api_version => p_api_version,
1258 p_init_msg_list => p_init_msg_list,
1259 x_return_status => x_return_status,
1260 x_msg_count => x_msg_count,
1261 x_msg_data => x_msg_data,
1262 p_chrv_rec => p_chrv_tbl(i));
1263
1264 -- store the highest degree of error
1265 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1266 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1267 l_overall_status := x_return_status;
1268 End If;
1269 End If;
1270 EXIT WHEN (i = p_chrv_tbl.LAST);
1271 i := p_chrv_tbl.NEXT(i);
1272 END LOOP;
1273 -- return overall status
1274 x_return_status := l_overall_status;
1275 End If;
1276
1277 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1278 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1279 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1280 raise OKC_API.G_EXCEPTION_ERROR;
1281 End If;
1282
1283 -- end activity
1284 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1285 x_msg_data => x_msg_data);
1286 EXCEPTION
1287 when OKC_API.G_EXCEPTION_ERROR then
1288 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1289 p_api_name => l_api_name,
1290 p_pkg_name => g_pkg_name,
1291 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1292 x_msg_count => x_msg_count,
1293 x_msg_data => x_msg_data,
1294 p_api_type => g_api_type);
1295
1296 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1297 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1298 p_api_name => l_api_name,
1299 p_pkg_name => g_pkg_name,
1300 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1301 x_msg_count => x_msg_count,
1302 x_msg_data => x_msg_data,
1303 p_api_type => g_api_type);
1304
1305 when OTHERS then
1306 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1307 p_api_name => l_api_name,
1308 p_pkg_name => g_pkg_name,
1309 p_exc_name => 'OTHERS',
1310 x_msg_count => x_msg_count,
1311 x_msg_data => x_msg_data,
1312 p_api_type => g_api_type);
1313
1314 END validate_contract_header;
1315
1316 PROCEDURE create_contract_line(
1317 p_api_version IN NUMBER,
1318 p_init_msg_list IN VARCHAR2 ,
1319 x_return_status OUT NOCOPY VARCHAR2,
1320 x_msg_count OUT NOCOPY NUMBER,
1321 x_msg_data OUT NOCOPY VARCHAR2,
1322 p_restricted_update IN VARCHAR2 ,
1323 p_clev_rec IN clev_rec_type,
1324 x_clev_rec OUT NOCOPY clev_rec_type) IS
1325
1326 l_clev_rec clev_rec_type;
1327 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_LINE';
1328 l_api_version CONSTANT NUMBER := 1.0;
1329 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1330 BEGIN
1331 -- call START_ACTIVITY to create savepoint, check compatibility
1332 -- and initialize message list
1333 l_return_status := OKC_API.START_ACTIVITY(
1334 p_api_name => l_api_name,
1335 p_pkg_name => g_pkg_name,
1336 p_init_msg_list => p_init_msg_list,
1337 l_api_version => l_api_version,
1338 p_api_version => p_api_version,
1339 p_api_type => g_api_type,
1340 x_return_status => x_return_status);
1341
1342 -- check if activity started successfully
1343 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1344 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1345 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1346 raise OKC_API.G_EXCEPTION_ERROR;
1347 End If;
1348
1349 -- call BEFORE user hook
1350 l_clev_rec := p_clev_rec;
1351 g_clev_rec := l_clev_rec;
1352
1353 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1354 p_package_name => g_pkg_name,
1355 p_procedure_name => l_api_name,
1356 p_before_after => 'B');
1357
1358 -- check return status of user hook call
1359 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1360 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1361 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1362 raise OKC_API.G_EXCEPTION_ERROR;
1363 End If;
1364
1365 -- get values back from user hook call
1366 l_clev_rec := g_clev_rec;
1367 l_clev_rec.id := p_clev_rec.id;
1368 l_clev_rec.object_version_number := p_clev_rec.object_version_number;
1369
1370 -- call procedure in complex API
1371 OKC_CONTRACT_PVT.create_contract_line(
1372 p_api_version => p_api_version,
1373 p_init_msg_list => p_init_msg_list,
1374 x_return_status => x_return_status,
1375 x_msg_count => x_msg_count,
1376 x_msg_data => x_msg_data,
1377 p_restricted_update=> p_restricted_update,
1378 p_clev_rec => l_clev_rec,
1379 x_clev_rec => x_clev_rec);
1380
1381 -- check return status
1382 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1383 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1384 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1385 raise OKC_API.G_EXCEPTION_ERROR;
1386 End If;
1387
1388 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1389 p_package_name => g_pkg_name,
1390 p_procedure_name => l_api_name,
1391 p_before_after => 'A');
1392
1393 -- check return status of the user hook call
1394 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1395 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1396 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1397 raise OKC_API.G_EXCEPTION_ERROR;
1398 End If;
1399
1400 -- end activity
1401 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1402 x_msg_data => x_msg_data);
1403 EXCEPTION
1404 when OKC_API.G_EXCEPTION_ERROR then
1405 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1406 p_api_name => l_api_name,
1407 p_pkg_name => g_pkg_name,
1408 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1409 x_msg_count => x_msg_count,
1410 x_msg_data => x_msg_data,
1411 p_api_type => g_api_type);
1412
1413 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1414 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1415 p_api_name => l_api_name,
1416 p_pkg_name => g_pkg_name,
1417 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1418 x_msg_count => x_msg_count,
1419 x_msg_data => x_msg_data,
1420 p_api_type => g_api_type);
1421
1422 when OTHERS then
1423 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1424 p_api_name => l_api_name,
1425 p_pkg_name => g_pkg_name,
1426 p_exc_name => 'OTHERS',
1427 x_msg_count => x_msg_count,
1428 x_msg_data => x_msg_data,
1429 p_api_type => g_api_type);
1430
1431 END create_contract_line;
1432
1433 PROCEDURE create_contract_line(
1434 p_api_version IN NUMBER,
1435 p_init_msg_list IN VARCHAR2 ,
1436 x_return_status OUT NOCOPY VARCHAR2,
1437 x_msg_count OUT NOCOPY NUMBER,
1438 x_msg_data OUT NOCOPY VARCHAR2,
1439 p_restricted_update IN VARCHAR2 ,
1440 p_clev_tbl IN clev_tbl_type,
1441 x_clev_tbl OUT NOCOPY clev_tbl_type) IS
1442
1443 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_LINE';
1444 l_api_version CONSTANT NUMBER := 1.0;
1445 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1446 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1447 i NUMBER;
1448 BEGIN
1449 -- call START_ACTIVITY to create savepoint, check compatibility
1450 -- and initialize message list
1451 l_return_status := OKC_API.START_ACTIVITY(
1452 p_api_name => l_api_name,
1453 p_pkg_name => g_pkg_name,
1454 p_init_msg_list => p_init_msg_list,
1455 l_api_version => l_api_version,
1456 p_api_version => p_api_version,
1457 p_api_type => g_api_type,
1458 x_return_status => x_return_status);
1459
1460 -- check if activity started successfully
1461 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1462 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1463 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1464 raise OKC_API.G_EXCEPTION_ERROR;
1465 End If;
1466
1467 If (p_clev_tbl.COUNT > 0) Then
1468 i := p_clev_tbl.FIRST;
1469 LOOP
1470 -- call procedure in complex API
1471 OKC_CONTRACT_PVT.create_contract_line(
1472 p_api_version => p_api_version,
1473 p_init_msg_list => p_init_msg_list,
1474 x_return_status => x_return_status,
1475 x_msg_count => x_msg_count,
1476 x_msg_data => x_msg_data,
1477 p_restricted_update => p_restricted_update,
1478 p_clev_rec => p_clev_tbl(i),
1479 x_clev_rec => x_clev_tbl(i));
1480
1481 -- store the highest degree of error
1482 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1483 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1484 l_overall_status := x_return_status;
1485 End If;
1486 End If;
1487 EXIT WHEN (i = p_clev_tbl.LAST);
1488 i := p_clev_tbl.NEXT(i);
1489 END LOOP;
1490 -- return overall status
1491 x_return_status := l_overall_status;
1492 End If;
1493
1494 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1495 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1496 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1497 raise OKC_API.G_EXCEPTION_ERROR;
1498 End If;
1499
1500 -- end activity
1501 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1502 x_msg_data => x_msg_data);
1503 EXCEPTION
1504 when OKC_API.G_EXCEPTION_ERROR then
1505 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1506 p_api_name => l_api_name,
1507 p_pkg_name => g_pkg_name,
1508 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1509 x_msg_count => x_msg_count,
1510 x_msg_data => x_msg_data,
1511 p_api_type => g_api_type);
1512
1513 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1514 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1515 p_api_name => l_api_name,
1516 p_pkg_name => g_pkg_name,
1517 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1518 x_msg_count => x_msg_count,
1519 x_msg_data => x_msg_data,
1520 p_api_type => g_api_type);
1521
1522 when OTHERS then
1523 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1524 p_api_name => l_api_name,
1525 p_pkg_name => g_pkg_name,
1526 p_exc_name => 'OTHERS',
1527 x_msg_count => x_msg_count,
1528 x_msg_data => x_msg_data,
1529 p_api_type => g_api_type);
1530
1531 END create_contract_line;
1532
1533 PROCEDURE update_contract_line(
1534 p_api_version IN NUMBER,
1535 p_init_msg_list IN VARCHAR2 ,
1536 x_return_status OUT NOCOPY VARCHAR2,
1537 x_msg_count OUT NOCOPY NUMBER,
1538 x_msg_data OUT NOCOPY VARCHAR2,
1539 p_restricted_update IN VARCHAR2 ,
1540 p_clev_rec IN clev_rec_type,
1541 x_clev_rec OUT NOCOPY clev_rec_type) IS
1542
1543 l_clev_rec clev_rec_type;
1544 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_LINE';
1545 l_api_version CONSTANT NUMBER := 1.0;
1546 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1547 BEGIN
1548 -- call START_ACTIVITY to create savepoint, check compatibility
1549 -- and initialize message list
1550 l_return_status := OKC_API.START_ACTIVITY(
1551 p_api_name => l_api_name,
1552 p_pkg_name => g_pkg_name,
1553 p_init_msg_list => p_init_msg_list,
1554 l_api_version => l_api_version,
1555 p_api_version => p_api_version,
1556 p_api_type => g_api_type,
1557 x_return_status => x_return_status);
1558
1559 -- check if activity started successfully
1560 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1561 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1562 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1563 raise OKC_API.G_EXCEPTION_ERROR;
1564 End If;
1565
1566 -- call BEFORE user hook
1567 l_clev_rec := p_clev_rec;
1568 g_clev_rec := l_clev_rec;
1569
1570 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1571 p_package_name => g_pkg_name,
1572 p_procedure_name => l_api_name,
1573 p_before_after => 'B');
1574
1575 -- check return status of user hook call
1576 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1577 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1578 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1579 raise OKC_API.G_EXCEPTION_ERROR;
1580 End If;
1581
1582 -- get values back from user hook call
1583 l_clev_rec := g_clev_rec;
1584 l_clev_rec.id := p_clev_rec.id;
1585 l_clev_rec.object_version_number := p_clev_rec.object_version_number;
1586
1587 -- call procedure in complex API
1588 OKC_CONTRACT_PVT.update_contract_line(
1589 p_api_version => p_api_version,
1590 p_init_msg_list => p_init_msg_list,
1591 x_return_status => x_return_status,
1592 x_msg_count => x_msg_count,
1593 x_msg_data => x_msg_data,
1594 p_restricted_update => p_restricted_update,
1595 p_clev_rec => l_clev_rec,
1596 x_clev_rec => x_clev_rec);
1597
1598 -- check return status
1599 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1600 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1601 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1602 raise OKC_API.G_EXCEPTION_ERROR;
1603 End If;
1604
1605 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1606 p_package_name => g_pkg_name,
1607 p_procedure_name => l_api_name,
1608 p_before_after => 'A');
1609
1610 -- check return status of the user hook call
1611 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1612 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1613 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1614 raise OKC_API.G_EXCEPTION_ERROR;
1615 End If;
1616
1617 -- end activity
1618 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1619 x_msg_data => x_msg_data);
1620 EXCEPTION
1621 when OKC_API.G_EXCEPTION_ERROR then
1622 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1623 p_api_name => l_api_name,
1624 p_pkg_name => g_pkg_name,
1625 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1626 x_msg_count => x_msg_count,
1627 x_msg_data => x_msg_data,
1628 p_api_type => g_api_type);
1629
1630 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1631 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1632 p_api_name => l_api_name,
1633 p_pkg_name => g_pkg_name,
1634 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1635 x_msg_count => x_msg_count,
1636 x_msg_data => x_msg_data,
1637 p_api_type => g_api_type);
1638
1639 when OTHERS then
1640 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1641 p_api_name => l_api_name,
1642 p_pkg_name => g_pkg_name,
1643 p_exc_name => 'OTHERS',
1644 x_msg_count => x_msg_count,
1645 x_msg_data => x_msg_data,
1646 p_api_type => g_api_type);
1647
1648 END update_contract_line;
1649
1650 PROCEDURE update_contract_line(
1651 p_api_version IN NUMBER,
1652 p_init_msg_list IN VARCHAR2 ,
1653 x_return_status OUT NOCOPY VARCHAR2,
1654 x_msg_count OUT NOCOPY NUMBER,
1655 x_msg_data OUT NOCOPY VARCHAR2,
1656 p_restricted_update IN VARCHAR2 ,
1657 p_clev_tbl IN clev_tbl_type,
1658 x_clev_tbl OUT NOCOPY clev_tbl_type) IS
1659
1660 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_LINE';
1661 l_api_version CONSTANT NUMBER := 1.0;
1662 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1663 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1664 i NUMBER;
1665 BEGIN
1666 -- call START_ACTIVITY to create savepoint, check compatibility
1667 -- and initialize message list
1668 l_return_status := OKC_API.START_ACTIVITY(
1669 p_api_name => l_api_name,
1670 p_pkg_name => g_pkg_name,
1671 p_init_msg_list => p_init_msg_list,
1672 l_api_version => l_api_version,
1673 p_api_version => p_api_version,
1674 p_api_type => g_api_type,
1675 x_return_status => x_return_status);
1676
1677 -- check if activity started successfully
1678 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1679 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1680 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1681 raise OKC_API.G_EXCEPTION_ERROR;
1682 End If;
1683
1684 If (p_clev_tbl.COUNT > 0) Then
1685 i := p_clev_tbl.FIRST;
1686 LOOP
1687 -- call procedure in complex API
1688 OKC_CONTRACT_PUB.update_contract_line(
1689 p_api_version => p_api_version,
1690 p_init_msg_list => p_init_msg_list,
1691 x_return_status => x_return_status,
1692 x_msg_count => x_msg_count,
1693 x_msg_data => x_msg_data,
1694 p_restricted_update => p_restricted_update,
1695 p_clev_rec => p_clev_tbl(i),
1696 x_clev_rec => x_clev_tbl(i));
1697
1698 -- store the highest degree of error
1699 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1700 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1701 l_overall_status := x_return_status;
1702 End If;
1703 End If;
1704 EXIT WHEN (i = p_clev_tbl.LAST);
1705 i := p_clev_tbl.NEXT(i);
1706 END LOOP;
1707 -- return overall status
1708 x_return_status := l_overall_status;
1709 End If;
1710
1711 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1712 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1713 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1714 raise OKC_API.G_EXCEPTION_ERROR;
1715 End If;
1716
1717 -- end activity
1718 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1719 x_msg_data => x_msg_data);
1720 EXCEPTION
1721 when OKC_API.G_EXCEPTION_ERROR then
1722 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1723 p_api_name => l_api_name,
1724 p_pkg_name => g_pkg_name,
1725 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1726 x_msg_count => x_msg_count,
1727 x_msg_data => x_msg_data,
1728 p_api_type => g_api_type);
1729
1730 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1731 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1732 p_api_name => l_api_name,
1733 p_pkg_name => g_pkg_name,
1734 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1735 x_msg_count => x_msg_count,
1736 x_msg_data => x_msg_data,
1737 p_api_type => g_api_type);
1738
1739 when OTHERS then
1740 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1741 p_api_name => l_api_name,
1742 p_pkg_name => g_pkg_name,
1743 p_exc_name => 'OTHERS',
1744 x_msg_count => x_msg_count,
1745 x_msg_data => x_msg_data,
1746 p_api_type => g_api_type);
1747
1748 END update_contract_line;
1749
1750 PROCEDURE delete_contract_line(
1751 p_api_version IN NUMBER,
1752 p_init_msg_list IN VARCHAR2 ,
1753 x_return_status OUT NOCOPY VARCHAR2,
1754 x_msg_count OUT NOCOPY NUMBER,
1755 x_msg_data OUT NOCOPY VARCHAR2,
1756 p_clev_rec IN clev_rec_type) IS
1757
1758 l_clev_rec clev_rec_type;
1759 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_LINE';
1760 l_api_version CONSTANT NUMBER := 1.0;
1761 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1762 BEGIN
1763 -- call START_ACTIVITY to create savepoint, check compatibility
1764 -- and initialize message list
1765 l_return_status := OKC_API.START_ACTIVITY(
1766 p_api_name => l_api_name,
1767 p_pkg_name => g_pkg_name,
1768 p_init_msg_list => p_init_msg_list,
1769 l_api_version => l_api_version,
1770 p_api_version => p_api_version,
1771 p_api_type => g_api_type,
1772 x_return_status => x_return_status);
1773
1774 -- check if activity started successfully
1775 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1776 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1777 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1778 raise OKC_API.G_EXCEPTION_ERROR;
1779 End If;
1780
1781 -- call BEFORE user hook
1782 l_clev_rec := p_clev_rec;
1783 g_clev_rec := l_clev_rec;
1784
1785 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1786 p_package_name => g_pkg_name,
1787 p_procedure_name => l_api_name,
1788 p_before_after => 'B');
1789
1790 -- check return status of user hook call
1791 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1792 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1793 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1794 raise OKC_API.G_EXCEPTION_ERROR;
1795 End If;
1796
1797 -- get values back from user hook call
1798 l_clev_rec := g_clev_rec;
1799 l_clev_rec.id := p_clev_rec.id;
1800 l_clev_rec.object_version_number := p_clev_rec.object_version_number;
1801
1802 -- call procedure in complex API
1803 OKC_CONTRACT_PVT.delete_contract_line(
1804 p_api_version => p_api_version,
1805 p_init_msg_list => p_init_msg_list,
1806 x_return_status => x_return_status,
1807 x_msg_count => x_msg_count,
1808 x_msg_data => x_msg_data,
1809 p_clev_rec => l_clev_rec);
1810
1811 -- check return status
1812 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1813 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1814 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1815 raise OKC_API.G_EXCEPTION_ERROR;
1816 End If;
1817
1818 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
1819 p_package_name => g_pkg_name,
1820 p_procedure_name => l_api_name,
1821 p_before_after => 'A');
1822
1823 -- check return status of the user hook call
1824 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1825 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1826 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1827 raise OKC_API.G_EXCEPTION_ERROR;
1828 End If;
1829
1830 -- end activity
1831 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1832 x_msg_data => x_msg_data);
1833 EXCEPTION
1834 when OKC_API.G_EXCEPTION_ERROR then
1835 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1836 p_api_name => l_api_name,
1837 p_pkg_name => g_pkg_name,
1838 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1839 x_msg_count => x_msg_count,
1840 x_msg_data => x_msg_data,
1841 p_api_type => g_api_type);
1842
1843 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1844 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1845 p_api_name => l_api_name,
1846 p_pkg_name => g_pkg_name,
1847 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1848 x_msg_count => x_msg_count,
1849 x_msg_data => x_msg_data,
1850 p_api_type => g_api_type);
1851
1852 when OTHERS then
1853 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1854 p_api_name => l_api_name,
1855 p_pkg_name => g_pkg_name,
1856 p_exc_name => 'OTHERS',
1857 x_msg_count => x_msg_count,
1858 x_msg_data => x_msg_data,
1859 p_api_type => g_api_type);
1860
1861 END delete_contract_line;
1862
1863 PROCEDURE delete_contract_line(
1864 p_api_version IN NUMBER,
1865 p_init_msg_list IN VARCHAR2 ,
1866 x_return_status OUT NOCOPY VARCHAR2,
1867 x_msg_count OUT NOCOPY NUMBER,
1868 x_msg_data OUT NOCOPY VARCHAR2,
1869 p_clev_tbl IN clev_tbl_type) IS
1870
1871 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_LINE';
1872 l_api_version CONSTANT NUMBER := 1.0;
1873 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1874 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1875 i NUMBER;
1876 BEGIN
1877 -- call START_ACTIVITY to create savepoint, check compatibility
1878 -- and initialize message list
1879 l_return_status := OKC_API.START_ACTIVITY(
1880 p_api_name => l_api_name,
1881 p_pkg_name => g_pkg_name,
1882 p_init_msg_list => p_init_msg_list,
1883 l_api_version => l_api_version,
1884 p_api_version => p_api_version,
1885 p_api_type => g_api_type,
1886 x_return_status => x_return_status);
1887
1888 -- check if activity started successfully
1889 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1890 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1891 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
1892 raise OKC_API.G_EXCEPTION_ERROR;
1893 End If;
1894
1895 If (p_clev_tbl.COUNT > 0) Then
1896 i := p_clev_tbl.FIRST;
1897 LOOP
1898 -- call procedure in complex API
1899 OKC_CONTRACT_PVT.delete_contract_line(
1900 p_api_version => p_api_version,
1901 p_init_msg_list => p_init_msg_list,
1902 x_return_status => x_return_status,
1903 x_msg_count => x_msg_count,
1904 x_msg_data => x_msg_data,
1905 p_clev_rec => p_clev_tbl(i));
1906
1907 -- store the highest degree of error
1908 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
1909 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
1910 l_overall_status := x_return_status;
1911 End If;
1912 End If;
1913 EXIT WHEN (i = p_clev_tbl.LAST);
1914 i := p_clev_tbl.NEXT(i);
1915 END LOOP;
1916 -- return overall status
1917 x_return_status := l_overall_status;
1918 End If;
1919
1920 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
1921 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1922 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
1923 raise OKC_API.G_EXCEPTION_ERROR;
1924 End If;
1925
1926 -- end activity
1927 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
1928 x_msg_data => x_msg_data);
1929 EXCEPTION
1930 when OKC_API.G_EXCEPTION_ERROR then
1931 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1932 p_api_name => l_api_name,
1933 p_pkg_name => g_pkg_name,
1934 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1935 x_msg_count => x_msg_count,
1936 x_msg_data => x_msg_data,
1937 p_api_type => g_api_type);
1938
1939 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1940 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1941 p_api_name => l_api_name,
1942 p_pkg_name => g_pkg_name,
1943 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1944 x_msg_count => x_msg_count,
1945 x_msg_data => x_msg_data,
1946 p_api_type => g_api_type);
1947
1948 when OTHERS then
1949 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1950 p_api_name => l_api_name,
1951 p_pkg_name => g_pkg_name,
1952 p_exc_name => 'OTHERS',
1953 x_msg_count => x_msg_count,
1954 x_msg_data => x_msg_data,
1955 p_api_type => g_api_type);
1956
1957 END delete_contract_line;
1958
1959 PROCEDURE delete_contract_line(
1960 p_api_version IN NUMBER,
1961 p_init_msg_list IN VARCHAR2 ,
1962 x_return_status OUT NOCOPY VARCHAR2,
1963 x_msg_count OUT NOCOPY NUMBER,
1964 x_msg_data OUT NOCOPY VARCHAR2,
1965 p_line_id IN NUMBER) IS
1966
1967 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_LINE';
1968 BEGIN
1969
1970 OKC_CONTRACT_PVT.delete_contract_line(
1971 p_api_version => p_api_version,
1972 p_init_msg_list => p_init_msg_list,
1973 x_return_status => x_return_status,
1974 x_msg_count => x_msg_count,
1975 x_msg_data => x_msg_data,
1976 p_line_id => p_line_id);
1977
1978 EXCEPTION
1979 when OTHERS then
1980 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1981 p_api_name => l_api_name,
1982 p_pkg_name => g_pkg_name,
1983 p_exc_name => 'OTHERS',
1984 x_msg_count => x_msg_count,
1985 x_msg_data => x_msg_data,
1986 p_api_type => g_api_type);
1987
1988 END delete_contract_line;
1989
1990 PROCEDURE lock_contract_line(
1991 p_api_version IN NUMBER,
1992 p_init_msg_list IN VARCHAR2 ,
1993 x_return_status OUT NOCOPY VARCHAR2,
1994 x_msg_count OUT NOCOPY NUMBER,
1995 x_msg_data OUT NOCOPY VARCHAR2,
1996 p_clev_rec IN clev_rec_type) IS
1997
1998 l_clev_rec clev_rec_type;
1999 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_LINE';
2000 l_api_version CONSTANT NUMBER := 1.0;
2001 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2002 BEGIN
2003 -- call START_ACTIVITY to create savepoint, check compatibility
2004 -- and initialize message list
2005 l_return_status := OKC_API.START_ACTIVITY(
2006 p_api_name => l_api_name,
2007 p_pkg_name => g_pkg_name,
2008 p_init_msg_list => p_init_msg_list,
2009 l_api_version => l_api_version,
2010 p_api_version => p_api_version,
2011 p_api_type => g_api_type,
2012 x_return_status => x_return_status);
2013
2014 -- check if activity started successfully
2015 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2016 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2017 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2018 raise OKC_API.G_EXCEPTION_ERROR;
2019 End If;
2020
2021 -- call BEFORE user hook
2022 l_clev_rec := p_clev_rec;
2023 g_clev_rec := l_clev_rec;
2024
2025 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2026 p_package_name => g_pkg_name,
2027 p_procedure_name => l_api_name,
2028 p_before_after => 'B');
2029
2030 -- check return status of user hook call
2031 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2032 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2033 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2034 raise OKC_API.G_EXCEPTION_ERROR;
2035 End If;
2036
2037 -- get values back from user hook call
2038 l_clev_rec := g_clev_rec;
2039 l_clev_rec.id := p_clev_rec.id;
2040 l_clev_rec.object_version_number := p_clev_rec.object_version_number;
2041
2042 -- call procedure in complex API
2043 OKC_CONTRACT_PVT.lock_contract_line(
2044 p_api_version => p_api_version,
2045 p_init_msg_list => p_init_msg_list,
2046 x_return_status => x_return_status,
2047 x_msg_count => x_msg_count,
2048 x_msg_data => x_msg_data,
2049 p_clev_rec => l_clev_rec);
2050
2051 -- check return status
2052 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2053 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2054 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2055 raise OKC_API.G_EXCEPTION_ERROR;
2056 End If;
2057
2058 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2059 p_package_name => g_pkg_name,
2060 p_procedure_name => l_api_name,
2061 p_before_after => 'A');
2062
2063 -- check return status of the user hook call
2064 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2065 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2066 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2067 raise OKC_API.G_EXCEPTION_ERROR;
2068 End If;
2069
2070 -- end activity
2071 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2072 x_msg_data => x_msg_data);
2073 EXCEPTION
2074 when OKC_API.G_EXCEPTION_ERROR then
2075 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2076 p_api_name => l_api_name,
2077 p_pkg_name => g_pkg_name,
2078 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2079 x_msg_count => x_msg_count,
2080 x_msg_data => x_msg_data,
2081 p_api_type => g_api_type);
2082
2083 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2084 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2085 p_api_name => l_api_name,
2086 p_pkg_name => g_pkg_name,
2087 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2088 x_msg_count => x_msg_count,
2089 x_msg_data => x_msg_data,
2090 p_api_type => g_api_type);
2091
2092 when OTHERS then
2093 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2094 p_api_name => l_api_name,
2095 p_pkg_name => g_pkg_name,
2096 p_exc_name => 'OTHERS',
2097 x_msg_count => x_msg_count,
2098 x_msg_data => x_msg_data,
2099 p_api_type => g_api_type);
2100
2101 END lock_contract_line;
2102
2103 PROCEDURE lock_contract_line(
2104 p_api_version IN NUMBER,
2105 p_init_msg_list IN VARCHAR2 ,
2106 x_return_status OUT NOCOPY VARCHAR2,
2107 x_msg_count OUT NOCOPY NUMBER,
2108 x_msg_data OUT NOCOPY VARCHAR2,
2109 p_clev_tbl IN clev_tbl_type) IS
2110
2111 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_HEADER';
2112 l_api_version CONSTANT NUMBER := 1.0;
2113 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2114 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2115 i NUMBER;
2116 BEGIN
2117 -- call START_ACTIVITY to create savepoint, check compatibility
2118 -- and initialize message list
2119 l_return_status := OKC_API.START_ACTIVITY(
2120 p_api_name => l_api_name,
2121 p_pkg_name => g_pkg_name,
2122 p_init_msg_list => p_init_msg_list,
2123 l_api_version => l_api_version,
2124 p_api_version => p_api_version,
2125 p_api_type => g_api_type,
2126 x_return_status => x_return_status);
2127
2128 -- check if activity started successfully
2129 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2130 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2131 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2132 raise OKC_API.G_EXCEPTION_ERROR;
2133 End If;
2134
2135 If (p_clev_tbl.COUNT > 0) Then
2136 i := p_clev_tbl.FIRST;
2137 LOOP
2138 -- call procedure in complex API
2139 OKC_CONTRACT_PVT.lock_contract_line(
2140 p_api_version => p_api_version,
2141 p_init_msg_list => p_init_msg_list,
2142 x_return_status => x_return_status,
2143 x_msg_count => x_msg_count,
2144 x_msg_data => x_msg_data,
2145 p_clev_rec => p_clev_tbl(i));
2146
2147 -- store the highest degree of error
2148 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2149 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2150 l_overall_status := x_return_status;
2151 End If;
2152 End If;
2153 EXIT WHEN (i = p_clev_tbl.LAST);
2154 i := p_clev_tbl.NEXT(i);
2155 END LOOP;
2156 -- return overall status
2157 x_return_status := l_overall_status;
2158 End If;
2159
2160 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2161 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2162 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2163 raise OKC_API.G_EXCEPTION_ERROR;
2164 End If;
2165
2166 -- end activity
2167 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2168 x_msg_data => x_msg_data);
2169 EXCEPTION
2170 when OKC_API.G_EXCEPTION_ERROR then
2171 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2172 p_api_name => l_api_name,
2173 p_pkg_name => g_pkg_name,
2174 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2175 x_msg_count => x_msg_count,
2176 x_msg_data => x_msg_data,
2177 p_api_type => g_api_type);
2178
2179 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2180 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2181 p_api_name => l_api_name,
2182 p_pkg_name => g_pkg_name,
2183 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2184 x_msg_count => x_msg_count,
2185 x_msg_data => x_msg_data,
2186 p_api_type => g_api_type);
2187
2188 when OTHERS then
2189 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2190 p_api_name => l_api_name,
2191 p_pkg_name => g_pkg_name,
2192 p_exc_name => 'OTHERS',
2193 x_msg_count => x_msg_count,
2194 x_msg_data => x_msg_data,
2195 p_api_type => g_api_type);
2196
2197 END lock_contract_line;
2198
2199 PROCEDURE validate_contract_line(
2200 p_api_version IN NUMBER,
2201 p_init_msg_list IN VARCHAR2 ,
2202 x_return_status OUT NOCOPY VARCHAR2,
2203 x_msg_count OUT NOCOPY NUMBER,
2204 x_msg_data OUT NOCOPY VARCHAR2,
2205 p_clev_rec IN clev_rec_type) IS
2206
2207 l_clev_rec clev_rec_type;
2208 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_LINE';
2209 l_api_version CONSTANT NUMBER := 1.0;
2210 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2211 BEGIN
2212 -- call START_ACTIVITY to create savepoint, check compatibility
2213 -- and initialize message list
2214 l_return_status := OKC_API.START_ACTIVITY(
2215 p_api_name => l_api_name,
2216 p_pkg_name => g_pkg_name,
2217 p_init_msg_list => p_init_msg_list,
2218 l_api_version => l_api_version,
2219 p_api_version => p_api_version,
2220 p_api_type => g_api_type,
2221 x_return_status => x_return_status);
2222
2223 -- check if activity started successfully
2224 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2225 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2226 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2227 raise OKC_API.G_EXCEPTION_ERROR;
2228 End If;
2229
2230 -- call BEFORE user hook
2231 l_clev_rec := p_clev_rec;
2232 g_clev_rec := l_clev_rec;
2233
2234 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2235 p_package_name => g_pkg_name,
2236 p_procedure_name => l_api_name,
2237 p_before_after => 'B');
2238
2239 -- check return status of user hook call
2240 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2241 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2242 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2243 raise OKC_API.G_EXCEPTION_ERROR;
2244 End If;
2245
2246 -- get values back from user hook call
2247 l_clev_rec := g_clev_rec;
2248 l_clev_rec.id := p_clev_rec.id;
2249 l_clev_rec.object_version_number := p_clev_rec.object_version_number;
2250
2251 -- call procedure in complex API
2252 OKC_CONTRACT_PVT.validate_contract_line(
2253 p_api_version => p_api_version,
2254 p_init_msg_list => p_init_msg_list,
2255 x_return_status => x_return_status,
2256 x_msg_count => x_msg_count,
2257 x_msg_data => x_msg_data,
2258 p_clev_rec => l_clev_rec);
2259
2260 -- check return status
2261 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2262 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2263 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2264 raise OKC_API.G_EXCEPTION_ERROR;
2265 End If;
2266
2267 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2268 p_package_name => g_pkg_name,
2269 p_procedure_name => l_api_name,
2270 p_before_after => 'A');
2271
2272 -- check return status of the user hook call
2273 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2274 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2275 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2276 raise OKC_API.G_EXCEPTION_ERROR;
2277 End If;
2278
2279 -- end activity
2280 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2281 x_msg_data => x_msg_data);
2282 EXCEPTION
2283 when OKC_API.G_EXCEPTION_ERROR then
2284 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2285 p_api_name => l_api_name,
2286 p_pkg_name => g_pkg_name,
2287 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2288 x_msg_count => x_msg_count,
2289 x_msg_data => x_msg_data,
2290 p_api_type => g_api_type);
2291
2292 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2293 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2294 p_api_name => l_api_name,
2295 p_pkg_name => g_pkg_name,
2296 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2297 x_msg_count => x_msg_count,
2298 x_msg_data => x_msg_data,
2299 p_api_type => g_api_type);
2300
2301 when OTHERS then
2302 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2303 p_api_name => l_api_name,
2304 p_pkg_name => g_pkg_name,
2305 p_exc_name => 'OTHERS',
2306 x_msg_count => x_msg_count,
2307 x_msg_data => x_msg_data,
2308 p_api_type => g_api_type);
2309
2310 END validate_contract_line;
2311
2312 PROCEDURE validate_contract_line(
2313 p_api_version IN NUMBER,
2314 p_init_msg_list IN VARCHAR2 ,
2315 x_return_status OUT NOCOPY VARCHAR2,
2316 x_msg_count OUT NOCOPY NUMBER,
2317 x_msg_data OUT NOCOPY VARCHAR2,
2318 p_clev_tbl IN clev_tbl_type) IS
2319
2320 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_LINE';
2321 l_api_version CONSTANT NUMBER := 1.0;
2322 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2323 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2324 i NUMBER;
2325 BEGIN
2326 -- call START_ACTIVITY to create savepoint, check compatibility
2327 -- and initialize message list
2328 l_return_status := OKC_API.START_ACTIVITY(
2329 p_api_name => l_api_name,
2330 p_pkg_name => g_pkg_name,
2331 p_init_msg_list => p_init_msg_list,
2332 l_api_version => l_api_version,
2333 p_api_version => p_api_version,
2334 p_api_type => g_api_type,
2335 x_return_status => x_return_status);
2336
2337 -- check if activity started successfully
2338 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2339 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2340 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2341 raise OKC_API.G_EXCEPTION_ERROR;
2342 End If;
2343
2344 If (p_clev_tbl.COUNT > 0) Then
2345 i := p_clev_tbl.FIRST;
2346 LOOP
2347 -- call procedure in complex API
2348 OKC_CONTRACT_PVT.validate_contract_line(
2349 p_api_version => p_api_version,
2350 p_init_msg_list => p_init_msg_list,
2351 x_return_status => x_return_status,
2352 x_msg_count => x_msg_count,
2353 x_msg_data => x_msg_data,
2354 p_clev_rec => p_clev_tbl(i));
2355
2356 -- store the highest degree of error
2357 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2358 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2359 l_overall_status := x_return_status;
2360 End If;
2361 End If;
2362 EXIT WHEN (i = p_clev_tbl.LAST);
2363 i := p_clev_tbl.NEXT(i);
2364 END LOOP;
2365 -- return overall status
2366 x_return_status := l_overall_status;
2367 End If;
2368
2369 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2370 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2371 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2372 raise OKC_API.G_EXCEPTION_ERROR;
2373 End If;
2374
2375 -- end activity
2376 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2377 x_msg_data => x_msg_data);
2378 EXCEPTION
2379 when OKC_API.G_EXCEPTION_ERROR then
2380 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2381 p_api_name => l_api_name,
2382 p_pkg_name => g_pkg_name,
2383 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2384 x_msg_count => x_msg_count,
2385 x_msg_data => x_msg_data,
2386 p_api_type => g_api_type);
2387
2388 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2389 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2390 p_api_name => l_api_name,
2391 p_pkg_name => g_pkg_name,
2392 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2393 x_msg_count => x_msg_count,
2394 x_msg_data => x_msg_data,
2395 p_api_type => g_api_type);
2396
2397 when OTHERS then
2398 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2399 p_api_name => l_api_name,
2400 p_pkg_name => g_pkg_name,
2401 p_exc_name => 'OTHERS',
2402 x_msg_count => x_msg_count,
2403 x_msg_data => x_msg_data,
2404 p_api_type => g_api_type);
2405
2406 END validate_contract_line;
2407
2408 PROCEDURE create_governance(
2409 p_api_version IN NUMBER,
2410 p_init_msg_list IN VARCHAR2 ,
2411 x_return_status OUT NOCOPY VARCHAR2,
2412 x_msg_count OUT NOCOPY NUMBER,
2413 x_msg_data OUT NOCOPY VARCHAR2,
2414 p_gvev_rec IN gvev_rec_type,
2415 x_gvev_rec OUT NOCOPY gvev_rec_type) IS
2416
2417 l_gvev_rec gvev_rec_type;
2418 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_GOVERNANCE';
2419 l_api_version CONSTANT NUMBER := 1.0;
2420 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2421 BEGIN
2422 -- call START_ACTIVITY to create savepoint, check compatibility
2423 -- and initialize message list
2424 l_return_status := OKC_API.START_ACTIVITY(
2425 p_api_name => l_api_name,
2426 p_pkg_name => g_pkg_name,
2427 p_init_msg_list => p_init_msg_list,
2428 l_api_version => l_api_version,
2429 p_api_version => p_api_version,
2430 p_api_type => g_api_type,
2431 x_return_status => x_return_status);
2432
2433 -- check if activity started successfully
2434 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2435 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2436 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2437 raise OKC_API.G_EXCEPTION_ERROR;
2438 End If;
2439
2440 -- call BEFORE user hook
2441 l_gvev_rec := p_gvev_rec;
2442 g_gvev_rec := l_gvev_rec;
2443
2444 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2445 p_package_name => g_pkg_name,
2446 p_procedure_name => l_api_name,
2447 p_before_after => 'B');
2448
2449 -- check return status of user hook call
2450 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2451 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2452 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2453 raise OKC_API.G_EXCEPTION_ERROR;
2454 End If;
2455
2456 -- get values back from user hook call
2457 l_gvev_rec := g_gvev_rec;
2458 l_gvev_rec.id := p_gvev_rec.id;
2459 l_gvev_rec.object_version_number := p_gvev_rec.object_version_number;
2460
2461 -- call procedure in complex API
2462 OKC_CONTRACT_PVT.create_governance(
2463 p_api_version => p_api_version,
2464 p_init_msg_list => p_init_msg_list,
2465 x_return_status => x_return_status,
2466 x_msg_count => x_msg_count,
2467 x_msg_data => x_msg_data,
2468 p_gvev_rec => p_gvev_rec,
2469 x_gvev_rec => x_gvev_rec);
2470
2471 -- check return status
2472 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2473 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2474 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2475 raise OKC_API.G_EXCEPTION_ERROR;
2476 End If;
2477
2478 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2479 p_package_name => g_pkg_name,
2480 p_procedure_name => l_api_name,
2481 p_before_after => 'A');
2482
2483 -- check return status of the user hook call
2484 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2485 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2486 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2487 raise OKC_API.G_EXCEPTION_ERROR;
2488 End If;
2489
2490 -- end activity
2491 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2492 x_msg_data => x_msg_data);
2493 EXCEPTION
2494 when OKC_API.G_EXCEPTION_ERROR then
2495 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2496 p_api_name => l_api_name,
2497 p_pkg_name => g_pkg_name,
2498 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2499 x_msg_count => x_msg_count,
2500 x_msg_data => x_msg_data,
2501 p_api_type => g_api_type);
2502
2503 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2504 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2505 p_api_name => l_api_name,
2506 p_pkg_name => g_pkg_name,
2507 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2508 x_msg_count => x_msg_count,
2509 x_msg_data => x_msg_data,
2510 p_api_type => g_api_type);
2511
2512 when OTHERS then
2513 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2514 p_api_name => l_api_name,
2515 p_pkg_name => g_pkg_name,
2516 p_exc_name => 'OTHERS',
2517 x_msg_count => x_msg_count,
2518 x_msg_data => x_msg_data,
2519 p_api_type => g_api_type);
2520
2521 END create_governance;
2522
2523 PROCEDURE create_governance(
2524 p_api_version IN NUMBER,
2525 p_init_msg_list IN VARCHAR2 ,
2526 x_return_status OUT NOCOPY VARCHAR2,
2527 x_msg_count OUT NOCOPY NUMBER,
2528 x_msg_data OUT NOCOPY VARCHAR2,
2529 p_gvev_tbl IN gvev_tbl_type,
2530 x_gvev_tbl OUT NOCOPY gvev_tbl_type) IS
2531
2532 l_api_name CONSTANT VARCHAR2(30) :='CREATE_GOVERNANCE';
2533 l_api_version CONSTANT NUMBER := 1.0;
2534 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2535 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2536 i NUMBER;
2537 BEGIN
2538 -- call START_ACTIVITY to create savepoint, check compatibility
2539 -- and initialize message list
2540 l_return_status := OKC_API.START_ACTIVITY(
2541 p_api_name => l_api_name,
2542 p_pkg_name => g_pkg_name,
2543 p_init_msg_list => p_init_msg_list,
2544 l_api_version => l_api_version,
2545 p_api_version => p_api_version,
2546 p_api_type => g_api_type,
2547 x_return_status => x_return_status);
2548
2549 -- check if activity started successfully
2550 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2551 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2552 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2553 raise OKC_API.G_EXCEPTION_ERROR;
2554 End If;
2555
2556 If (p_gvev_tbl.COUNT > 0) Then
2557 i := p_gvev_tbl.FIRST;
2558 LOOP
2559 -- call procedure in complex API
2560 OKC_CONTRACT_PUB.create_governance(
2561 p_api_version => p_api_version,
2562 p_init_msg_list => p_init_msg_list,
2563 x_return_status => x_return_status,
2564 x_msg_count => x_msg_count,
2565 x_msg_data => x_msg_data,
2566 p_gvev_rec => p_gvev_tbl(i),
2567 x_gvev_rec => x_gvev_tbl(i));
2568
2569 -- store the highest degree of error
2570 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2571 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2572 l_overall_status := x_return_status;
2573 End If;
2574 End If;
2575 EXIT WHEN (i = p_gvev_tbl.LAST);
2576 i := p_gvev_tbl.NEXT(i);
2577 END LOOP;
2578 -- return overall status
2579 x_return_status := l_overall_status;
2580 End If;
2581
2582 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2583 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2584 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2585 raise OKC_API.G_EXCEPTION_ERROR;
2586 End If;
2587
2588 -- end activity
2589 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2590 x_msg_data => x_msg_data);
2591 EXCEPTION
2592 when OKC_API.G_EXCEPTION_ERROR then
2593 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2594 p_api_name => l_api_name,
2595 p_pkg_name => g_pkg_name,
2596 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2597 x_msg_count => x_msg_count,
2598 x_msg_data => x_msg_data,
2599 p_api_type => g_api_type);
2600
2601 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2602 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2603 p_api_name => l_api_name,
2604 p_pkg_name => g_pkg_name,
2605 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2606 x_msg_count => x_msg_count,
2607 x_msg_data => x_msg_data,
2608 p_api_type => g_api_type);
2609
2610 when OTHERS then
2611 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2612 p_api_name => l_api_name,
2613 p_pkg_name => g_pkg_name,
2614 p_exc_name => 'OTHERS',
2615 x_msg_count => x_msg_count,
2616 x_msg_data => x_msg_data,
2617 p_api_type => g_api_type);
2618
2619 END create_governance;
2620
2621 PROCEDURE update_governance(
2622 p_api_version IN NUMBER,
2623 p_init_msg_list IN VARCHAR2 ,
2624 x_return_status OUT NOCOPY VARCHAR2,
2625 x_msg_count OUT NOCOPY NUMBER,
2626 x_msg_data OUT NOCOPY VARCHAR2,
2627 p_gvev_rec IN gvev_rec_type,
2628 x_gvev_rec OUT NOCOPY gvev_rec_type) IS
2629
2630 l_gvev_rec gvev_rec_type;
2631 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_GOVERNANCE';
2632 l_api_version CONSTANT NUMBER := 1.0;
2633 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2634 BEGIN
2635 -- call START_ACTIVITY to create savepoint, check compatibility
2636 -- and initialize message list
2637 l_return_status := OKC_API.START_ACTIVITY(
2638 p_api_name => l_api_name,
2639 p_pkg_name => g_pkg_name,
2640 p_init_msg_list => p_init_msg_list,
2641 l_api_version => l_api_version,
2642 p_api_version => p_api_version,
2643 p_api_type => g_api_type,
2644 x_return_status => x_return_status);
2645
2646 -- check if activity started successfully
2647 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2648 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2649 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2650 raise OKC_API.G_EXCEPTION_ERROR;
2651 End If;
2652
2653 -- call BEFORE user hook
2654 l_gvev_rec := p_gvev_rec;
2655 g_gvev_rec := l_gvev_rec;
2656
2657 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2658 p_package_name => g_pkg_name,
2659 p_procedure_name => l_api_name,
2660 p_before_after => 'B');
2661
2662 -- check return status of user hook call
2663 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2664 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2665 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2666 raise OKC_API.G_EXCEPTION_ERROR;
2667 End If;
2668
2669 -- get values back from user hook call
2670 l_gvev_rec := g_gvev_rec;
2671 l_gvev_rec.id := p_gvev_rec.id;
2672 l_gvev_rec.object_version_number := p_gvev_rec.object_version_number;
2673
2674 -- call procedure in complex API
2675 OKC_CONTRACT_PVT.update_governance(
2676 p_api_version => p_api_version,
2677 p_init_msg_list => p_init_msg_list,
2678 x_return_status => x_return_status,
2679 x_msg_count => x_msg_count,
2680 x_msg_data => x_msg_data,
2681 p_gvev_rec => l_gvev_rec,
2682 x_gvev_rec => x_gvev_rec);
2683
2684 -- check return status
2685 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2686 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2687 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2688 raise OKC_API.G_EXCEPTION_ERROR;
2689 End If;
2690
2691 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2692 p_package_name => g_pkg_name,
2693 p_procedure_name => l_api_name,
2694 p_before_after => 'A');
2695
2696 -- check return status of the user hook call
2697 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2698 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2699 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2700 raise OKC_API.G_EXCEPTION_ERROR;
2701 End If;
2702
2703 -- end activity
2704 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2705 x_msg_data => x_msg_data);
2706 EXCEPTION
2707 when OKC_API.G_EXCEPTION_ERROR then
2708 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2709 p_api_name => l_api_name,
2710 p_pkg_name => g_pkg_name,
2711 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2712 x_msg_count => x_msg_count,
2713 x_msg_data => x_msg_data,
2714 p_api_type => g_api_type);
2715
2716 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2717 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2718 p_api_name => l_api_name,
2719 p_pkg_name => g_pkg_name,
2720 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2721 x_msg_count => x_msg_count,
2722 x_msg_data => x_msg_data,
2723 p_api_type => g_api_type);
2724
2725 when OTHERS then
2726 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2727 p_api_name => l_api_name,
2728 p_pkg_name => g_pkg_name,
2729 p_exc_name => 'OTHERS',
2730 x_msg_count => x_msg_count,
2731 x_msg_data => x_msg_data,
2732 p_api_type => g_api_type);
2733
2734 END update_governance;
2735
2736 PROCEDURE update_governance(
2737 p_api_version IN NUMBER,
2738 p_init_msg_list IN VARCHAR2 ,
2739 x_return_status OUT NOCOPY VARCHAR2,
2740 x_msg_count OUT NOCOPY NUMBER,
2741 x_msg_data OUT NOCOPY VARCHAR2,
2742 p_gvev_tbl IN gvev_tbl_type,
2743 x_gvev_tbl OUT NOCOPY gvev_tbl_type) IS
2744
2745 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_GOVERNANCE';
2746 l_api_version CONSTANT NUMBER := 1.0;
2747 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2748 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2749 i NUMBER;
2750 BEGIN
2751 -- call START_ACTIVITY to create savepoint, check compatibility
2752 -- and initialize message list
2753 l_return_status := OKC_API.START_ACTIVITY(
2754 p_api_name => l_api_name,
2755 p_pkg_name => g_pkg_name,
2756 p_init_msg_list => p_init_msg_list,
2757 l_api_version => l_api_version,
2758 p_api_version => p_api_version,
2759 p_api_type => g_api_type,
2760 x_return_status => x_return_status);
2761
2762 -- check if activity started successfully
2763 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2764 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2765 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2766 raise OKC_API.G_EXCEPTION_ERROR;
2767 End If;
2768
2769 If (p_gvev_tbl.COUNT > 0) Then
2770 i := p_gvev_tbl.FIRST;
2771 LOOP
2772 -- call procedure in complex API
2773 OKC_CONTRACT_PUB.update_governance(
2774 p_api_version => p_api_version,
2775 p_init_msg_list => p_init_msg_list,
2776 x_return_status => x_return_status,
2777 x_msg_count => x_msg_count,
2778 x_msg_data => x_msg_data,
2779 p_gvev_rec => p_gvev_tbl(i),
2780 x_gvev_rec => x_gvev_tbl(i));
2781
2782 -- store the highest degree of error
2783 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2784 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2785 l_overall_status := x_return_status;
2786 End If;
2787 End If;
2788 EXIT WHEN (i = p_gvev_tbl.LAST);
2789 i := p_gvev_tbl.NEXT(i);
2790 END LOOP;
2791 -- return overall status
2792 x_return_status := l_overall_status;
2793 End If;
2794
2795 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2796 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2797 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2798 raise OKC_API.G_EXCEPTION_ERROR;
2799 End If;
2800
2801 -- end activity
2802 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2803 x_msg_data => x_msg_data);
2804 EXCEPTION
2805 when OKC_API.G_EXCEPTION_ERROR then
2806 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2807 p_api_name => l_api_name,
2808 p_pkg_name => g_pkg_name,
2809 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2810 x_msg_count => x_msg_count,
2811 x_msg_data => x_msg_data,
2812 p_api_type => g_api_type);
2813
2814 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2815 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2816 p_api_name => l_api_name,
2817 p_pkg_name => g_pkg_name,
2818 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2819 x_msg_count => x_msg_count,
2820 x_msg_data => x_msg_data,
2821 p_api_type => g_api_type);
2822
2823 when OTHERS then
2824 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2825 p_api_name => l_api_name,
2826 p_pkg_name => g_pkg_name,
2827 p_exc_name => 'OTHERS',
2828 x_msg_count => x_msg_count,
2829 x_msg_data => x_msg_data,
2830 p_api_type => g_api_type);
2831
2832 END update_governance;
2833
2834 PROCEDURE delete_governance(
2835 p_api_version IN NUMBER,
2836 p_init_msg_list IN VARCHAR2 ,
2837 x_return_status OUT NOCOPY VARCHAR2,
2838 x_msg_count OUT NOCOPY NUMBER,
2839 x_msg_data OUT NOCOPY VARCHAR2,
2840 p_gvev_rec IN gvev_rec_type) IS
2841
2842 l_gvev_rec gvev_rec_type;
2843 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_GOVERNANCE';
2844 l_api_version CONSTANT NUMBER := 1.0;
2845 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2846 BEGIN
2847 -- call START_ACTIVITY to create savepoint, check compatibility
2848 -- and initialize message list
2849 l_return_status := OKC_API.START_ACTIVITY(
2850 p_api_name => l_api_name,
2851 p_pkg_name => g_pkg_name,
2852 p_init_msg_list => p_init_msg_list,
2853 l_api_version => l_api_version,
2854 p_api_version => p_api_version,
2855 p_api_type => g_api_type,
2856 x_return_status => x_return_status);
2857
2858 -- check if activity started successfully
2859 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2860 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2861 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2862 raise OKC_API.G_EXCEPTION_ERROR;
2863 End If;
2864
2865 -- call BEFORE user hook
2866 l_gvev_rec := p_gvev_rec;
2867 g_gvev_rec := l_gvev_rec;
2868
2869 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2870 p_package_name => g_pkg_name,
2871 p_procedure_name => l_api_name,
2872 p_before_after => 'B');
2873
2874 -- check return status of user hook call
2875 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2876 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2877 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2878 raise OKC_API.G_EXCEPTION_ERROR;
2879 End If;
2880
2881 -- get values back from user hook call
2882 l_gvev_rec := g_gvev_rec;
2883 l_gvev_rec.id := p_gvev_rec.id;
2884 l_gvev_rec.object_version_number := p_gvev_rec.object_version_number;
2885
2886 -- call procedure in complex API
2887 OKC_CONTRACT_PVT.delete_governance(
2888 p_api_version => p_api_version,
2889 p_init_msg_list => p_init_msg_list,
2890 x_return_status => x_return_status,
2891 x_msg_count => x_msg_count,
2892 x_msg_data => x_msg_data,
2893 p_gvev_rec => l_gvev_rec);
2894
2895 -- check return status
2896 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2897 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2898 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2899 raise OKC_API.G_EXCEPTION_ERROR;
2900 End If;
2901
2902 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
2903 p_package_name => g_pkg_name,
2904 p_procedure_name => l_api_name,
2905 p_before_after => 'A');
2906
2907 -- check return status of the user hook call
2908 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
2909 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2910 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
2911 raise OKC_API.G_EXCEPTION_ERROR;
2912 End If;
2913
2914 -- end activity
2915 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
2916 x_msg_data => x_msg_data);
2917 EXCEPTION
2918 when OKC_API.G_EXCEPTION_ERROR then
2919 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2920 p_api_name => l_api_name,
2921 p_pkg_name => g_pkg_name,
2922 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2923 x_msg_count => x_msg_count,
2924 x_msg_data => x_msg_data,
2925 p_api_type => g_api_type);
2926
2927 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2928 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2929 p_api_name => l_api_name,
2930 p_pkg_name => g_pkg_name,
2931 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2932 x_msg_count => x_msg_count,
2933 x_msg_data => x_msg_data,
2934 p_api_type => g_api_type);
2935
2936 when OTHERS then
2937 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2938 p_api_name => l_api_name,
2939 p_pkg_name => g_pkg_name,
2940 p_exc_name => 'OTHERS',
2941 x_msg_count => x_msg_count,
2942 x_msg_data => x_msg_data,
2943 p_api_type => g_api_type);
2944
2945 END delete_governance;
2946
2947 PROCEDURE delete_governance(
2948 p_api_version IN NUMBER,
2949 p_init_msg_list IN VARCHAR2 ,
2950 x_return_status OUT NOCOPY VARCHAR2,
2951 x_msg_count OUT NOCOPY NUMBER,
2952 x_msg_data OUT NOCOPY VARCHAR2,
2953 p_gvev_tbl IN gvev_tbl_type) IS
2954
2955 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_GOVERNANCE';
2956 l_api_version CONSTANT NUMBER := 1.0;
2957 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2958 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2959 i NUMBER;
2960 BEGIN
2961 -- call START_ACTIVITY to create savepoint, check compatibility
2962 -- and initialize message list
2963 l_return_status := OKC_API.START_ACTIVITY(
2964 p_api_name => l_api_name,
2965 p_pkg_name => g_pkg_name,
2966 p_init_msg_list => p_init_msg_list,
2967 l_api_version => l_api_version,
2968 p_api_version => p_api_version,
2969 p_api_type => g_api_type,
2970 x_return_status => x_return_status);
2971
2972 -- check if activity started successfully
2973 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2974 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2975 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
2976 raise OKC_API.G_EXCEPTION_ERROR;
2977 End If;
2978
2979 If (p_gvev_tbl.COUNT > 0) Then
2980 i := p_gvev_tbl.FIRST;
2981 LOOP
2982 -- call procedure in complex API
2983 OKC_CONTRACT_PUB.delete_governance(
2984 p_api_version => p_api_version,
2985 p_init_msg_list => p_init_msg_list,
2986 x_return_status => x_return_status,
2987 x_msg_count => x_msg_count,
2988 x_msg_data => x_msg_data,
2989 p_gvev_rec => p_gvev_tbl(i));
2990
2991 -- store the highest degree of error
2992 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
2993 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
2994 l_overall_status := x_return_status;
2995 End If;
2996 End If;
2997 EXIT WHEN (i = p_gvev_tbl.LAST);
2998 i := p_gvev_tbl.NEXT(i);
2999 END LOOP;
3000 -- return overall status
3001 x_return_status := l_overall_status;
3002 End If;
3003
3004 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3005 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3006 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3007 raise OKC_API.G_EXCEPTION_ERROR;
3008 End If;
3009
3010 -- end activity
3011 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3012 x_msg_data => x_msg_data);
3013 EXCEPTION
3014 when OKC_API.G_EXCEPTION_ERROR then
3015 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3016 p_api_name => l_api_name,
3017 p_pkg_name => g_pkg_name,
3018 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3019 x_msg_count => x_msg_count,
3020 x_msg_data => x_msg_data,
3021 p_api_type => g_api_type);
3022
3023 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3024 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3025 p_api_name => l_api_name,
3026 p_pkg_name => g_pkg_name,
3027 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3028 x_msg_count => x_msg_count,
3029 x_msg_data => x_msg_data,
3030 p_api_type => g_api_type);
3031
3032 when OTHERS then
3033 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3034 p_api_name => l_api_name,
3035 p_pkg_name => g_pkg_name,
3036 p_exc_name => 'OTHERS',
3037 x_msg_count => x_msg_count,
3038 x_msg_data => x_msg_data,
3039 p_api_type => g_api_type);
3040
3041 END delete_governance;
3042
3043 PROCEDURE lock_governance(
3044 p_api_version IN NUMBER,
3045 p_init_msg_list IN VARCHAR2 ,
3046 x_return_status OUT NOCOPY VARCHAR2,
3047 x_msg_count OUT NOCOPY NUMBER,
3048 x_msg_data OUT NOCOPY VARCHAR2,
3049 p_gvev_rec IN gvev_rec_type) IS
3050
3051 l_gvev_rec gvev_rec_type;
3052 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_GOVERNANCE';
3053 l_api_version CONSTANT NUMBER := 1.0;
3054 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3055 BEGIN
3056 -- call START_ACTIVITY to create savepoint, check compatibility
3057 -- and initialize message list
3058 l_return_status := OKC_API.START_ACTIVITY(
3059 p_api_name => l_api_name,
3060 p_pkg_name => g_pkg_name,
3061 p_init_msg_list => p_init_msg_list,
3062 l_api_version => l_api_version,
3063 p_api_version => p_api_version,
3064 p_api_type => g_api_type,
3065 x_return_status => x_return_status);
3066
3067 -- check if activity started successfully
3068 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3069 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3070 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3071 raise OKC_API.G_EXCEPTION_ERROR;
3072 End If;
3073
3074 -- call BEFORE user hook
3075 l_gvev_rec := p_gvev_rec;
3076 g_gvev_rec := l_gvev_rec;
3077
3078 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3079 p_package_name => g_pkg_name,
3080 p_procedure_name => l_api_name,
3081 p_before_after => 'B');
3082
3083 -- check return status of user hook call
3084 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3085 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3086 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3087 raise OKC_API.G_EXCEPTION_ERROR;
3088 End If;
3089
3090 -- get values back from user hook call
3091 l_gvev_rec := g_gvev_rec;
3092 l_gvev_rec.id := p_gvev_rec.id;
3093 l_gvev_rec.object_version_number := p_gvev_rec.object_version_number;
3094
3095 -- call procedure in complex API
3096 OKC_CONTRACT_PVT.lock_governance(
3097 p_api_version => p_api_version,
3098 p_init_msg_list => p_init_msg_list,
3099 x_return_status => x_return_status,
3100 x_msg_count => x_msg_count,
3101 x_msg_data => x_msg_data,
3102 p_gvev_rec => l_gvev_rec);
3103
3104 -- check return status
3105 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3106 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3107 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3108 raise OKC_API.G_EXCEPTION_ERROR;
3109 End If;
3110
3111 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3112 p_package_name => g_pkg_name,
3113 p_procedure_name => l_api_name,
3114 p_before_after => 'A');
3115
3116 -- check return status of the user hook call
3117 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3118 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3119 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3120 raise OKC_API.G_EXCEPTION_ERROR;
3121 End If;
3122
3123 -- end activity
3124 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3125 x_msg_data => x_msg_data);
3126 EXCEPTION
3127 when OKC_API.G_EXCEPTION_ERROR then
3128 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3129 p_api_name => l_api_name,
3130 p_pkg_name => g_pkg_name,
3131 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3132 x_msg_count => x_msg_count,
3133 x_msg_data => x_msg_data,
3134 p_api_type => g_api_type);
3135
3136 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3137 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3138 p_api_name => l_api_name,
3139 p_pkg_name => g_pkg_name,
3140 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3141 x_msg_count => x_msg_count,
3142 x_msg_data => x_msg_data,
3143 p_api_type => g_api_type);
3144
3145 when OTHERS then
3146 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3147 p_api_name => l_api_name,
3148 p_pkg_name => g_pkg_name,
3149 p_exc_name => 'OTHERS',
3150 x_msg_count => x_msg_count,
3151 x_msg_data => x_msg_data,
3152 p_api_type => g_api_type);
3153
3154 END lock_governance;
3155
3156 PROCEDURE lock_governance(
3157 p_api_version IN NUMBER,
3158 p_init_msg_list IN VARCHAR2 ,
3159 x_return_status OUT NOCOPY VARCHAR2,
3160 x_msg_count OUT NOCOPY NUMBER,
3161 x_msg_data OUT NOCOPY VARCHAR2,
3162 p_gvev_tbl IN gvev_tbl_type) IS
3163
3164 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_GOVERNANCE';
3165 l_api_version CONSTANT NUMBER := 1.0;
3166 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3167 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3168 i NUMBER;
3169 BEGIN
3170 -- call START_ACTIVITY to create savepoint, check compatibility
3171 -- and initialize message list
3172 l_return_status := OKC_API.START_ACTIVITY(
3173 p_api_name => l_api_name,
3174 p_pkg_name => g_pkg_name,
3175 p_init_msg_list => p_init_msg_list,
3176 l_api_version => l_api_version,
3177 p_api_version => p_api_version,
3178 p_api_type => g_api_type,
3179 x_return_status => x_return_status);
3180
3181 -- check if activity started successfully
3182 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3183 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3184 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3185 raise OKC_API.G_EXCEPTION_ERROR;
3186 End If;
3187
3188 If (p_gvev_tbl.COUNT > 0) Then
3189 i := p_gvev_tbl.FIRST;
3190 LOOP
3191 -- call procedure in complex API
3192 OKC_CONTRACT_PUB.lock_governance(
3193 p_api_version => p_api_version,
3194 p_init_msg_list => p_init_msg_list,
3195 x_return_status => x_return_status,
3196 x_msg_count => x_msg_count,
3197 x_msg_data => x_msg_data,
3198 p_gvev_rec => p_gvev_tbl(i));
3199
3200 -- store the highest degree of error
3201 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3202 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3203 l_overall_status := x_return_status;
3204 End If;
3205 End If;
3206 EXIT WHEN (i = p_gvev_tbl.LAST);
3207 i := p_gvev_tbl.NEXT(i);
3208 END LOOP;
3209 -- return overall status
3210 x_return_status := l_overall_status;
3211 End If;
3212
3213 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3214 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3215 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3216 raise OKC_API.G_EXCEPTION_ERROR;
3217 End If;
3218
3219 -- end activity
3220 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3221 x_msg_data => x_msg_data);
3222 EXCEPTION
3223 when OKC_API.G_EXCEPTION_ERROR then
3224 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3225 p_api_name => l_api_name,
3226 p_pkg_name => g_pkg_name,
3227 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3228 x_msg_count => x_msg_count,
3229 x_msg_data => x_msg_data,
3230 p_api_type => g_api_type);
3231
3232 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3233 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3234 p_api_name => l_api_name,
3235 p_pkg_name => g_pkg_name,
3236 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3237 x_msg_count => x_msg_count,
3238 x_msg_data => x_msg_data,
3239 p_api_type => g_api_type);
3240
3241 when OTHERS then
3242 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3243 p_api_name => l_api_name,
3244 p_pkg_name => g_pkg_name,
3245 p_exc_name => 'OTHERS',
3246 x_msg_count => x_msg_count,
3247 x_msg_data => x_msg_data,
3248 p_api_type => g_api_type);
3249
3250 END lock_governance;
3251
3252 PROCEDURE validate_governance(
3253 p_api_version IN NUMBER,
3254 p_init_msg_list IN VARCHAR2 ,
3255 x_return_status OUT NOCOPY VARCHAR2,
3256 x_msg_count OUT NOCOPY NUMBER,
3257 x_msg_data OUT NOCOPY VARCHAR2,
3258 p_gvev_rec IN gvev_rec_type) IS
3259
3260 l_gvev_rec gvev_rec_type;
3261 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_GOVERNANCE';
3262 l_api_version CONSTANT NUMBER := 1.0;
3263 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3264 BEGIN
3265 -- call START_ACTIVITY to create savepoint, check compatibility
3266 -- and initialize message list
3267 l_return_status := OKC_API.START_ACTIVITY(
3268 p_api_name => l_api_name,
3269 p_pkg_name => g_pkg_name,
3270 p_init_msg_list => p_init_msg_list,
3271 l_api_version => l_api_version,
3272 p_api_version => p_api_version,
3273 p_api_type => g_api_type,
3274 x_return_status => x_return_status);
3275
3276 -- check if activity started successfully
3277 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3278 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3279 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3280 raise OKC_API.G_EXCEPTION_ERROR;
3281 End If;
3282
3283 -- call BEFORE user hook
3284 l_gvev_rec := p_gvev_rec;
3285 g_gvev_rec := l_gvev_rec;
3286
3287 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3288 p_package_name => g_pkg_name,
3289 p_procedure_name => l_api_name,
3290 p_before_after => 'B');
3291
3292 -- check return status of user hook call
3293 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3294 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3295 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3296 raise OKC_API.G_EXCEPTION_ERROR;
3297 End If;
3298
3299 -- get values back from user hook call
3300 l_gvev_rec := g_gvev_rec;
3301 l_gvev_rec.id := p_gvev_rec.id;
3302 l_gvev_rec.object_version_number := p_gvev_rec.object_version_number;
3303
3304 -- call procedure in complex API
3305 OKC_CONTRACT_PVT.validate_governance(
3306 p_api_version => p_api_version,
3307 p_init_msg_list => p_init_msg_list,
3308 x_return_status => x_return_status,
3309 x_msg_count => x_msg_count,
3310 x_msg_data => x_msg_data,
3311 p_gvev_rec => l_gvev_rec);
3312
3313 -- check return status
3314 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3315 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3316 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3317 raise OKC_API.G_EXCEPTION_ERROR;
3318 End If;
3319
3320 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3321 p_package_name => g_pkg_name,
3322 p_procedure_name => l_api_name,
3323 p_before_after => 'A');
3324
3325 -- check return status of the user hook call
3326 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3327 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3328 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3329 raise OKC_API.G_EXCEPTION_ERROR;
3330 End If;
3331
3332 -- end activity
3333 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3334 x_msg_data => x_msg_data);
3335 EXCEPTION
3336 when OKC_API.G_EXCEPTION_ERROR then
3337 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3338 p_api_name => l_api_name,
3339 p_pkg_name => g_pkg_name,
3340 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3341 x_msg_count => x_msg_count,
3342 x_msg_data => x_msg_data,
3343 p_api_type => g_api_type);
3344
3345 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3346 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3347 p_api_name => l_api_name,
3348 p_pkg_name => g_pkg_name,
3349 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3350 x_msg_count => x_msg_count,
3351 x_msg_data => x_msg_data,
3352 p_api_type => g_api_type);
3353
3354 when OTHERS then
3355 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3356 p_api_name => l_api_name,
3357 p_pkg_name => g_pkg_name,
3358 p_exc_name => 'OTHERS',
3359 x_msg_count => x_msg_count,
3360 x_msg_data => x_msg_data,
3361 p_api_type => g_api_type);
3362
3363 END validate_governance;
3364
3365 PROCEDURE validate_governance(
3366 p_api_version IN NUMBER,
3367 p_init_msg_list IN VARCHAR2 ,
3368 x_return_status OUT NOCOPY VARCHAR2,
3369 x_msg_count OUT NOCOPY NUMBER,
3370 x_msg_data OUT NOCOPY VARCHAR2,
3371 p_gvev_tbl IN gvev_tbl_type) IS
3372
3373 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_GOVERNANCE';
3374 l_api_version CONSTANT NUMBER := 1.0;
3375 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3376 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3377 i NUMBER;
3378 BEGIN
3379 -- call START_ACTIVITY to create savepoint, check compatibility
3380 -- and initialize message list
3381 l_return_status := OKC_API.START_ACTIVITY(
3382 p_api_name => l_api_name,
3383 p_pkg_name => g_pkg_name,
3384 p_init_msg_list => p_init_msg_list,
3385 l_api_version => l_api_version,
3386 p_api_version => p_api_version,
3387 p_api_type => g_api_type,
3388 x_return_status => x_return_status);
3389
3390 -- check if activity started successfully
3391 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3392 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3393 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3394 raise OKC_API.G_EXCEPTION_ERROR;
3395 End If;
3396
3397 If (p_gvev_tbl.COUNT > 0) Then
3398 i := p_gvev_tbl.FIRST;
3399 LOOP
3400 -- call procedure in complex API
3401 OKC_CONTRACT_PUB.validate_governance(
3402 p_api_version => p_api_version,
3403 p_init_msg_list => p_init_msg_list,
3404 x_return_status => x_return_status,
3405 x_msg_count => x_msg_count,
3406 x_msg_data => x_msg_data,
3407 p_gvev_rec => p_gvev_tbl(i));
3408
3409 -- store the highest degree of error
3410 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3411 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3412 l_overall_status := x_return_status;
3413 End If;
3414 End If;
3415 EXIT WHEN (i = p_gvev_tbl.LAST);
3416 i := p_gvev_tbl.NEXT(i);
3417 END LOOP;
3418 -- return overall status
3419 x_return_status := l_overall_status;
3420 End If;
3421
3422 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3423 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3424 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3425 raise OKC_API.G_EXCEPTION_ERROR;
3426 End If;
3427
3428 -- end activity
3429 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3430 x_msg_data => x_msg_data);
3431 EXCEPTION
3432 when OKC_API.G_EXCEPTION_ERROR then
3433 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3434 p_api_name => l_api_name,
3435 p_pkg_name => g_pkg_name,
3436 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3437 x_msg_count => x_msg_count,
3438 x_msg_data => x_msg_data,
3439 p_api_type => g_api_type);
3440
3441 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3442 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3443 p_api_name => l_api_name,
3444 p_pkg_name => g_pkg_name,
3445 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3446 x_msg_count => x_msg_count,
3447 x_msg_data => x_msg_data,
3448 p_api_type => g_api_type);
3449
3450 when OTHERS then
3451 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3452 p_api_name => l_api_name,
3453 p_pkg_name => g_pkg_name,
3454 p_exc_name => 'OTHERS',
3455 x_msg_count => x_msg_count,
3456 x_msg_data => x_msg_data,
3457 p_api_type => g_api_type);
3458
3459 END validate_governance;
3460
3461 PROCEDURE create_contract_process(
3462 p_api_version IN NUMBER,
3463 p_init_msg_list IN VARCHAR2 ,
3464 x_return_status OUT NOCOPY VARCHAR2,
3465 x_msg_count OUT NOCOPY NUMBER,
3466 x_msg_data OUT NOCOPY VARCHAR2,
3467 p_cpsv_rec IN cpsv_rec_type,
3468 x_cpsv_rec OUT NOCOPY cpsv_rec_type) IS
3469
3470 l_cpsv_rec cpsv_rec_type;
3471 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_PROCESS';
3472 l_api_version CONSTANT NUMBER := 1.0;
3473 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3474 BEGIN
3475 -- call START_ACTIVITY to create savepoint, check compatibility
3476 -- and initialize message list
3477 l_return_status := OKC_API.START_ACTIVITY(
3478 p_api_name => l_api_name,
3479 p_pkg_name => g_pkg_name,
3480 p_init_msg_list => p_init_msg_list,
3481 l_api_version => l_api_version,
3482 p_api_version => p_api_version,
3483 p_api_type => g_api_type,
3484 x_return_status => x_return_status);
3485
3486 -- check if activity started successfully
3487 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3488 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3489 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3490 raise OKC_API.G_EXCEPTION_ERROR;
3491 End If;
3492
3493 -- call BEFORE user hook
3494 l_cpsv_rec := p_cpsv_rec;
3495 g_cpsv_rec := l_cpsv_rec;
3496
3497 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3498 p_package_name => g_pkg_name,
3499 p_procedure_name => l_api_name,
3500 p_before_after => 'B');
3501
3502 -- check return status of user hook call
3503 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3504 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3505 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3506 raise OKC_API.G_EXCEPTION_ERROR;
3507 End If;
3508
3509 -- get values back from user hook call
3510 l_cpsv_rec := g_cpsv_rec;
3511 l_cpsv_rec.id := p_cpsv_rec.id;
3512 l_cpsv_rec.object_version_number := p_cpsv_rec.object_version_number;
3513
3514 -- call procedure in complex API
3515 OKC_CONTRACT_PVT.create_contract_process(
3516 p_api_version => p_api_version,
3517 p_init_msg_list => p_init_msg_list,
3518 x_return_status => x_return_status,
3519 x_msg_count => x_msg_count,
3520 x_msg_data => x_msg_data,
3521 p_cpsv_rec => l_cpsv_rec,
3522 x_cpsv_rec => x_cpsv_rec);
3523
3524 -- check return status
3525 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3526 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3527 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3528 raise OKC_API.G_EXCEPTION_ERROR;
3529 End If;
3530
3531 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3532 p_package_name => g_pkg_name,
3533 p_procedure_name => l_api_name,
3534 p_before_after => 'A');
3535
3536 -- check return status of the user hook call
3537 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3538 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3539 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3540 raise OKC_API.G_EXCEPTION_ERROR;
3541 End If;
3542
3543 -- end activity
3544 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3545 x_msg_data => x_msg_data);
3546 EXCEPTION
3547 when OKC_API.G_EXCEPTION_ERROR then
3548 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3549 p_api_name => l_api_name,
3550 p_pkg_name => g_pkg_name,
3551 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3552 x_msg_count => x_msg_count,
3553 x_msg_data => x_msg_data,
3554 p_api_type => g_api_type);
3555
3556 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3557 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3558 p_api_name => l_api_name,
3559 p_pkg_name => g_pkg_name,
3560 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3561 x_msg_count => x_msg_count,
3562 x_msg_data => x_msg_data,
3563 p_api_type => g_api_type);
3564
3565 when OTHERS then
3566 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3567 p_api_name => l_api_name,
3568 p_pkg_name => g_pkg_name,
3569 p_exc_name => 'OTHERS',
3570 x_msg_count => x_msg_count,
3571 x_msg_data => x_msg_data,
3572 p_api_type => g_api_type);
3573
3574 END create_contract_process;
3575
3576 PROCEDURE create_contract_process(
3577 p_api_version IN NUMBER,
3578 p_init_msg_list IN VARCHAR2 ,
3579 x_return_status OUT NOCOPY VARCHAR2,
3580 x_msg_count OUT NOCOPY NUMBER,
3581 x_msg_data OUT NOCOPY VARCHAR2,
3582 p_cpsv_tbl IN cpsv_tbl_type,
3583 x_cpsv_tbl OUT NOCOPY cpsv_tbl_type) IS
3584
3585 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_PROCESS';
3586 l_api_version CONSTANT NUMBER := 1.0;
3587 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3588 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3589 i NUMBER;
3590 BEGIN
3591 -- call START_ACTIVITY to create savepoint, check compatibility
3592 -- and initialize message list
3593 l_return_status := OKC_API.START_ACTIVITY(
3594 p_api_name => l_api_name,
3595 p_pkg_name => g_pkg_name,
3596 p_init_msg_list => p_init_msg_list,
3597 l_api_version => l_api_version,
3598 p_api_version => p_api_version,
3599 p_api_type => g_api_type,
3600 x_return_status => x_return_status);
3601
3602 -- check if activity started successfully
3603 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3604 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3605 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3606 raise OKC_API.G_EXCEPTION_ERROR;
3607 End If;
3608
3609 If (p_cpsv_tbl.COUNT > 0) Then
3610 i := p_cpsv_tbl.FIRST;
3611 LOOP
3612 -- call procedure in complex API
3613 OKC_CONTRACT_PUB.create_contract_process(
3614 p_api_version => p_api_version,
3615 p_init_msg_list => p_init_msg_list,
3616 x_return_status => x_return_status,
3617 x_msg_count => x_msg_count,
3618 x_msg_data => x_msg_data,
3619 p_cpsv_rec => p_cpsv_tbl(i),
3620 x_cpsv_rec => x_cpsv_tbl(i));
3621
3622 -- store the highest degree of error
3623 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3624 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3625 l_overall_status := x_return_status;
3626 End If;
3627 End If;
3628 EXIT WHEN (i = p_cpsv_tbl.LAST);
3629 i := p_cpsv_tbl.NEXT(i);
3630 END LOOP;
3631 -- return overall status
3632 x_return_status := l_overall_status;
3633 End If;
3634
3635 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3636 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3637 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3638 raise OKC_API.G_EXCEPTION_ERROR;
3639 End If;
3640
3641 -- end activity
3642 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3643 x_msg_data => x_msg_data);
3644 EXCEPTION
3645 when OKC_API.G_EXCEPTION_ERROR then
3646 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3647 p_api_name => l_api_name,
3648 p_pkg_name => g_pkg_name,
3649 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3650 x_msg_count => x_msg_count,
3651 x_msg_data => x_msg_data,
3652 p_api_type => g_api_type);
3653
3654 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3655 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3656 p_api_name => l_api_name,
3657 p_pkg_name => g_pkg_name,
3658 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3659 x_msg_count => x_msg_count,
3660 x_msg_data => x_msg_data,
3661 p_api_type => g_api_type);
3662
3663 when OTHERS then
3664 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3665 p_api_name => l_api_name,
3666 p_pkg_name => g_pkg_name,
3667 p_exc_name => 'OTHERS',
3668 x_msg_count => x_msg_count,
3669 x_msg_data => x_msg_data,
3670 p_api_type => g_api_type);
3671
3672 END create_contract_process;
3673
3674 PROCEDURE update_contract_process(
3675 p_api_version IN NUMBER,
3676 p_init_msg_list IN VARCHAR2 ,
3677 x_return_status OUT NOCOPY VARCHAR2,
3678 x_msg_count OUT NOCOPY NUMBER,
3679 x_msg_data OUT NOCOPY VARCHAR2,
3680 p_cpsv_rec IN cpsv_rec_type,
3681 x_cpsv_rec OUT NOCOPY cpsv_rec_type) IS
3682
3683 l_cpsv_rec cpsv_rec_type;
3684 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_PROCESS';
3685 l_api_version CONSTANT NUMBER := 1.0;
3686 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3687 BEGIN
3688 -- call START_ACTIVITY to create savepoint, check compatibility
3689 -- and initialize message list
3690 l_return_status := OKC_API.START_ACTIVITY(
3691 p_api_name => l_api_name,
3692 p_pkg_name => g_pkg_name,
3693 p_init_msg_list => p_init_msg_list,
3694 l_api_version => l_api_version,
3695 p_api_version => p_api_version,
3696 p_api_type => g_api_type,
3697 x_return_status => x_return_status);
3698
3699 -- check if activity started successfully
3700 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3701 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3702 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3703 raise OKC_API.G_EXCEPTION_ERROR;
3704 End If;
3705
3706 -- call BEFORE user hook
3707 l_cpsv_rec := p_cpsv_rec;
3708 g_cpsv_rec := l_cpsv_rec;
3709
3710 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3711 p_package_name => g_pkg_name,
3712 p_procedure_name => l_api_name,
3713 p_before_after => 'B');
3714
3715 -- check return status of user hook call
3716 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3717 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3718 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3719 raise OKC_API.G_EXCEPTION_ERROR;
3720 End If;
3721
3722 -- get values back from user hook call
3723 l_cpsv_rec := g_cpsv_rec;
3724 l_cpsv_rec.id := p_cpsv_rec.id;
3725 l_cpsv_rec.object_version_number := p_cpsv_rec.object_version_number;
3726
3727 -- call procedure in complex API
3728 OKC_CONTRACT_PVT.update_contract_process(
3729 p_api_version => p_api_version,
3730 p_init_msg_list => p_init_msg_list,
3731 x_return_status => x_return_status,
3732 x_msg_count => x_msg_count,
3733 x_msg_data => x_msg_data,
3734 p_cpsv_rec => l_cpsv_rec,
3735 x_cpsv_rec => x_cpsv_rec);
3736
3737 -- check return status
3738 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3739 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3740 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3741 raise OKC_API.G_EXCEPTION_ERROR;
3742 End If;
3743
3744 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3745 p_package_name => g_pkg_name,
3746 p_procedure_name => l_api_name,
3747 p_before_after => 'A');
3748
3749 -- check return status of the user hook call
3750 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3751 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3752 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3753 raise OKC_API.G_EXCEPTION_ERROR;
3754 End If;
3755
3756 -- end activity
3757 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3758 x_msg_data => x_msg_data);
3759 EXCEPTION
3760 when OKC_API.G_EXCEPTION_ERROR then
3761 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3762 p_api_name => l_api_name,
3763 p_pkg_name => g_pkg_name,
3764 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3765 x_msg_count => x_msg_count,
3766 x_msg_data => x_msg_data,
3767 p_api_type => g_api_type);
3768
3769 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3770 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3771 p_api_name => l_api_name,
3772 p_pkg_name => g_pkg_name,
3773 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3774 x_msg_count => x_msg_count,
3775 x_msg_data => x_msg_data,
3776 p_api_type => g_api_type);
3777
3778 when OTHERS then
3779 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3780 p_api_name => l_api_name,
3781 p_pkg_name => g_pkg_name,
3782 p_exc_name => 'OTHERS',
3783 x_msg_count => x_msg_count,
3784 x_msg_data => x_msg_data,
3785 p_api_type => g_api_type);
3786
3787 END update_contract_process;
3788
3789 PROCEDURE update_contract_process(
3790 p_api_version IN NUMBER,
3791 p_init_msg_list IN VARCHAR2 ,
3792 x_return_status OUT NOCOPY VARCHAR2,
3793 x_msg_count OUT NOCOPY NUMBER,
3794 x_msg_data OUT NOCOPY VARCHAR2,
3795 p_cpsv_tbl IN cpsv_tbl_type,
3796 x_cpsv_tbl OUT NOCOPY cpsv_tbl_type) IS
3797
3798 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_PROCESS';
3799 l_api_version CONSTANT NUMBER := 1.0;
3800 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3801 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3802 i NUMBER;
3803 BEGIN
3804 -- call START_ACTIVITY to create savepoint, check compatibility
3805 -- and initialize message list
3806 l_return_status := OKC_API.START_ACTIVITY(
3807 p_api_name => l_api_name,
3808 p_pkg_name => g_pkg_name,
3809 p_init_msg_list => p_init_msg_list,
3810 l_api_version => l_api_version,
3811 p_api_version => p_api_version,
3812 p_api_type => g_api_type,
3813 x_return_status => x_return_status);
3814
3815 -- check if activity started successfully
3816 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3817 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3818 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3819 raise OKC_API.G_EXCEPTION_ERROR;
3820 End If;
3821
3822 If (p_cpsv_tbl.COUNT > 0) Then
3823 i := p_cpsv_tbl.FIRST;
3824 LOOP
3825 -- call procedure in complex API
3826 OKC_CONTRACT_PUB.update_contract_process(
3827 p_api_version => p_api_version,
3828 p_init_msg_list => p_init_msg_list,
3829 x_return_status => x_return_status,
3830 x_msg_count => x_msg_count,
3831 x_msg_data => x_msg_data,
3832 p_cpsv_rec => p_cpsv_tbl(i),
3833 x_cpsv_rec => x_cpsv_tbl(i));
3834
3835 -- store the highest degree of error
3836 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
3837 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
3838 l_overall_status := x_return_status;
3839 End If;
3840 End If;
3841 EXIT WHEN (i = p_cpsv_tbl.LAST);
3842 i := p_cpsv_tbl.NEXT(i);
3843 END LOOP;
3844 -- return overall status
3845 x_return_status := l_overall_status;
3846 End If;
3847
3848 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3849 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3850 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3851 raise OKC_API.G_EXCEPTION_ERROR;
3852 End If;
3853
3854 -- end activity
3855 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3856 x_msg_data => x_msg_data);
3857 EXCEPTION
3858 when OKC_API.G_EXCEPTION_ERROR then
3859 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3860 p_api_name => l_api_name,
3861 p_pkg_name => g_pkg_name,
3862 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3863 x_msg_count => x_msg_count,
3864 x_msg_data => x_msg_data,
3865 p_api_type => g_api_type);
3866
3867 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3868 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3869 p_api_name => l_api_name,
3870 p_pkg_name => g_pkg_name,
3871 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3872 x_msg_count => x_msg_count,
3873 x_msg_data => x_msg_data,
3874 p_api_type => g_api_type);
3875
3876 when OTHERS then
3877 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3878 p_api_name => l_api_name,
3879 p_pkg_name => g_pkg_name,
3880 p_exc_name => 'OTHERS',
3881 x_msg_count => x_msg_count,
3882 x_msg_data => x_msg_data,
3883 p_api_type => g_api_type);
3884
3885 END update_contract_process;
3886
3887 PROCEDURE delete_contract_process(
3888 p_api_version IN NUMBER,
3889 p_init_msg_list IN VARCHAR2 ,
3890 x_return_status OUT NOCOPY VARCHAR2,
3891 x_msg_count OUT NOCOPY NUMBER,
3892 x_msg_data OUT NOCOPY VARCHAR2,
3893 p_cpsv_rec IN cpsv_rec_type) IS
3894
3895 l_cpsv_rec cpsv_rec_type;
3896 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_PROCESS';
3897 l_api_version CONSTANT NUMBER := 1.0;
3898 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3899 BEGIN
3900 -- call START_ACTIVITY to create savepoint, check compatibility
3901 -- and initialize message list
3902 l_return_status := OKC_API.START_ACTIVITY(
3903 p_api_name => l_api_name,
3904 p_pkg_name => g_pkg_name,
3905 p_init_msg_list => p_init_msg_list,
3906 l_api_version => l_api_version,
3907 p_api_version => p_api_version,
3908 p_api_type => g_api_type,
3909 x_return_status => x_return_status);
3910
3911 -- check if activity started successfully
3912 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3913 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3914 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
3915 raise OKC_API.G_EXCEPTION_ERROR;
3916 End If;
3917
3918 -- call BEFORE user hook
3919 l_cpsv_rec := p_cpsv_rec;
3920 g_cpsv_rec := l_cpsv_rec;
3921
3922 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3923 p_package_name => g_pkg_name,
3924 p_procedure_name => l_api_name,
3925 p_before_after => 'B');
3926
3927 -- check return status of user hook call
3928 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3929 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3930 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3931 raise OKC_API.G_EXCEPTION_ERROR;
3932 End If;
3933
3934 -- get values back from user hook call
3935 l_cpsv_rec := g_cpsv_rec;
3936 l_cpsv_rec.id := p_cpsv_rec.id;
3937 l_cpsv_rec.object_version_number := p_cpsv_rec.object_version_number;
3938
3939 -- call procedure in complex API
3940 OKC_CONTRACT_PVT.delete_contract_process(
3941 p_api_version => p_api_version,
3942 p_init_msg_list => p_init_msg_list,
3943 x_return_status => x_return_status,
3944 x_msg_count => x_msg_count,
3945 x_msg_data => x_msg_data,
3946 p_cpsv_rec => l_cpsv_rec);
3947
3948 -- check return status
3949 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3950 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3951 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3952 raise OKC_API.G_EXCEPTION_ERROR;
3953 End If;
3954
3955 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
3956 p_package_name => g_pkg_name,
3957 p_procedure_name => l_api_name,
3958 p_before_after => 'A');
3959
3960 -- check return status of the user hook call
3961 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
3962 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3963 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
3964 raise OKC_API.G_EXCEPTION_ERROR;
3965 End If;
3966
3967 -- end activity
3968 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
3969 x_msg_data => x_msg_data);
3970 EXCEPTION
3971 when OKC_API.G_EXCEPTION_ERROR then
3972 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3973 p_api_name => l_api_name,
3974 p_pkg_name => g_pkg_name,
3975 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3976 x_msg_count => x_msg_count,
3977 x_msg_data => x_msg_data,
3978 p_api_type => g_api_type);
3979
3980 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3981 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3982 p_api_name => l_api_name,
3983 p_pkg_name => g_pkg_name,
3984 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3985 x_msg_count => x_msg_count,
3986 x_msg_data => x_msg_data,
3987 p_api_type => g_api_type);
3988
3989 when OTHERS then
3990 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3991 p_api_name => l_api_name,
3992 p_pkg_name => g_pkg_name,
3993 p_exc_name => 'OTHERS',
3994 x_msg_count => x_msg_count,
3995 x_msg_data => x_msg_data,
3996 p_api_type => g_api_type);
3997
3998 END delete_contract_process;
3999
4000 PROCEDURE delete_contract_process(
4001 p_api_version IN NUMBER,
4002 p_init_msg_list IN VARCHAR2 ,
4003 x_return_status OUT NOCOPY VARCHAR2,
4004 x_msg_count OUT NOCOPY NUMBER,
4005 x_msg_data OUT NOCOPY VARCHAR2,
4006 p_cpsv_tbl IN cpsv_tbl_type) IS
4007
4008 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_PROCESS';
4009 l_api_version CONSTANT NUMBER := 1.0;
4010 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4011 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4012 i NUMBER;
4013 BEGIN
4014 -- call START_ACTIVITY to create savepoint, check compatibility
4015 -- and initialize message list
4016 l_return_status := OKC_API.START_ACTIVITY(
4017 p_api_name => l_api_name,
4018 p_pkg_name => g_pkg_name,
4019 p_init_msg_list => p_init_msg_list,
4020 l_api_version => l_api_version,
4021 p_api_version => p_api_version,
4022 p_api_type => g_api_type,
4023 x_return_status => x_return_status);
4024
4025 -- check if activity started successfully
4026 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4027 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4028 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4029 raise OKC_API.G_EXCEPTION_ERROR;
4030 End If;
4031
4032 If (p_cpsv_tbl.COUNT > 0) Then
4033 i := p_cpsv_tbl.FIRST;
4034 LOOP
4035 -- call procedure in complex API
4036 OKC_CONTRACT_PUB.delete_contract_process(
4037 p_api_version => p_api_version,
4038 p_init_msg_list => p_init_msg_list,
4039 x_return_status => x_return_status,
4040 x_msg_count => x_msg_count,
4041 x_msg_data => x_msg_data,
4042 p_cpsv_rec => p_cpsv_tbl(i));
4043
4044 -- store the highest degree of error
4045 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
4046 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
4047 l_overall_status := x_return_status;
4048 End If;
4049 End If;
4050 EXIT WHEN (i = p_cpsv_tbl.LAST);
4051 i := p_cpsv_tbl.NEXT(i);
4052 END LOOP;
4053 -- return overall status
4054 x_return_status := l_overall_status;
4055 End If;
4056
4057 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4058 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4059 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4060 raise OKC_API.G_EXCEPTION_ERROR;
4061 End If;
4062
4063 -- end activity
4064 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4065 x_msg_data => x_msg_data);
4066 EXCEPTION
4067 when OKC_API.G_EXCEPTION_ERROR then
4068 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4069 p_api_name => l_api_name,
4070 p_pkg_name => g_pkg_name,
4071 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4072 x_msg_count => x_msg_count,
4073 x_msg_data => x_msg_data,
4074 p_api_type => g_api_type);
4075
4076 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4077 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4078 p_api_name => l_api_name,
4079 p_pkg_name => g_pkg_name,
4080 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4081 x_msg_count => x_msg_count,
4082 x_msg_data => x_msg_data,
4083 p_api_type => g_api_type);
4084
4085 when OTHERS then
4086 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4087 p_api_name => l_api_name,
4088 p_pkg_name => g_pkg_name,
4089 p_exc_name => 'OTHERS',
4090 x_msg_count => x_msg_count,
4091 x_msg_data => x_msg_data,
4092 p_api_type => g_api_type);
4093
4094 END delete_contract_process;
4095
4096 PROCEDURE lock_contract_process(
4097 p_api_version IN NUMBER,
4098 p_init_msg_list IN VARCHAR2 ,
4099 x_return_status OUT NOCOPY VARCHAR2,
4100 x_msg_count OUT NOCOPY NUMBER,
4101 x_msg_data OUT NOCOPY VARCHAR2,
4102 p_cpsv_rec IN cpsv_rec_type) IS
4103
4104 l_cpsv_rec cpsv_rec_type;
4105 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_PROCESS';
4106 l_api_version CONSTANT NUMBER := 1.0;
4107 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4108 BEGIN
4109 -- call START_ACTIVITY to create savepoint, check compatibility
4110 -- and initialize message list
4111 l_return_status := OKC_API.START_ACTIVITY(
4112 p_api_name => l_api_name,
4113 p_pkg_name => g_pkg_name,
4114 p_init_msg_list => p_init_msg_list,
4115 l_api_version => l_api_version,
4116 p_api_version => p_api_version,
4117 p_api_type => g_api_type,
4118 x_return_status => x_return_status);
4119
4120 -- check if activity started successfully
4121 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4122 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4123 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4124 raise OKC_API.G_EXCEPTION_ERROR;
4125 End If;
4126
4127 -- call BEFORE user hook
4128 l_cpsv_rec := p_cpsv_rec;
4129 g_cpsv_rec := l_cpsv_rec;
4130
4131 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4132 p_package_name => g_pkg_name,
4133 p_procedure_name => l_api_name,
4134 p_before_after => 'B');
4135
4136 -- check return status of user hook call
4137 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4138 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4139 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4140 raise OKC_API.G_EXCEPTION_ERROR;
4141 End If;
4142
4143 -- get values back from user hook call
4144 l_cpsv_rec := g_cpsv_rec;
4145 l_cpsv_rec.id := p_cpsv_rec.id;
4146 l_cpsv_rec.object_version_number := p_cpsv_rec.object_version_number;
4147
4148 -- call procedure in complex API
4149 OKC_CONTRACT_PVT.lock_contract_process(
4150 p_api_version => p_api_version,
4151 p_init_msg_list => p_init_msg_list,
4152 x_return_status => x_return_status,
4153 x_msg_count => x_msg_count,
4154 x_msg_data => x_msg_data,
4155 p_cpsv_rec => l_cpsv_rec);
4156
4157 -- check return status
4158 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4159 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4160 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4161 raise OKC_API.G_EXCEPTION_ERROR;
4162 End If;
4163
4164 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4165 p_package_name => g_pkg_name,
4166 p_procedure_name => l_api_name,
4167 p_before_after => 'A');
4168
4169 -- check return status of the user hook call
4170 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4171 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4172 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4173 raise OKC_API.G_EXCEPTION_ERROR;
4174 End If;
4175
4176 -- end activity
4177 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4178 x_msg_data => x_msg_data);
4179 EXCEPTION
4180 when OKC_API.G_EXCEPTION_ERROR then
4181 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4182 p_api_name => l_api_name,
4183 p_pkg_name => g_pkg_name,
4184 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4185 x_msg_count => x_msg_count,
4186 x_msg_data => x_msg_data,
4187 p_api_type => g_api_type);
4188
4189 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4190 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4191 p_api_name => l_api_name,
4192 p_pkg_name => g_pkg_name,
4193 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4194 x_msg_count => x_msg_count,
4195 x_msg_data => x_msg_data,
4196 p_api_type => g_api_type);
4197
4198 when OTHERS then
4199 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4200 p_api_name => l_api_name,
4201 p_pkg_name => g_pkg_name,
4202 p_exc_name => 'OTHERS',
4203 x_msg_count => x_msg_count,
4204 x_msg_data => x_msg_data,
4205 p_api_type => g_api_type);
4206
4207 END lock_contract_process;
4208
4209 PROCEDURE lock_contract_process(
4210 p_api_version IN NUMBER,
4211 p_init_msg_list IN VARCHAR2 ,
4212 x_return_status OUT NOCOPY VARCHAR2,
4213 x_msg_count OUT NOCOPY NUMBER,
4214 x_msg_data OUT NOCOPY VARCHAR2,
4215 p_cpsv_tbl IN cpsv_tbl_type) IS
4216
4217 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_PROCESS';
4218 l_api_version CONSTANT NUMBER := 1.0;
4219 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4220 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4221 i NUMBER;
4222 BEGIN
4223 -- call START_ACTIVITY to create savepoint, check compatibility
4224 -- and initialize message list
4225 l_return_status := OKC_API.START_ACTIVITY(
4226 p_api_name => l_api_name,
4227 p_pkg_name => g_pkg_name,
4228 p_init_msg_list => p_init_msg_list,
4229 l_api_version => l_api_version,
4230 p_api_version => p_api_version,
4231 p_api_type => g_api_type,
4232 x_return_status => x_return_status);
4233
4234 -- check if activity started successfully
4235 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4236 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4237 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4238 raise OKC_API.G_EXCEPTION_ERROR;
4239 End If;
4240
4241 If (p_cpsv_tbl.COUNT > 0) Then
4242 i := p_cpsv_tbl.FIRST;
4243 LOOP
4244 -- call procedure in complex API
4245 OKC_CONTRACT_PUB.lock_contract_process(
4246 p_api_version => p_api_version,
4247 p_init_msg_list => p_init_msg_list,
4248 x_return_status => x_return_status,
4249 x_msg_count => x_msg_count,
4250 x_msg_data => x_msg_data,
4251 p_cpsv_rec => p_cpsv_tbl(i));
4252
4253 -- store the highest degree of error
4254 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
4255 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
4256 l_overall_status := x_return_status;
4257 End If;
4258 End If;
4259 EXIT WHEN (i = p_cpsv_tbl.LAST);
4260 i := p_cpsv_tbl.NEXT(i);
4261 END LOOP;
4262 -- return overall status
4263 x_return_status := l_overall_status;
4264 End If;
4265
4266 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4267 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4268 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4269 raise OKC_API.G_EXCEPTION_ERROR;
4270 End If;
4271
4272 -- end activity
4273 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4274 x_msg_data => x_msg_data);
4275 EXCEPTION
4276 when OKC_API.G_EXCEPTION_ERROR then
4277 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4278 p_api_name => l_api_name,
4279 p_pkg_name => g_pkg_name,
4280 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4281 x_msg_count => x_msg_count,
4282 x_msg_data => x_msg_data,
4283 p_api_type => g_api_type);
4284
4285 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4286 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4287 p_api_name => l_api_name,
4288 p_pkg_name => g_pkg_name,
4289 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4290 x_msg_count => x_msg_count,
4291 x_msg_data => x_msg_data,
4292 p_api_type => g_api_type);
4293
4294 when OTHERS then
4295 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4296 p_api_name => l_api_name,
4297 p_pkg_name => g_pkg_name,
4298 p_exc_name => 'OTHERS',
4299 x_msg_count => x_msg_count,
4300 x_msg_data => x_msg_data,
4301 p_api_type => g_api_type);
4302
4303 END lock_contract_process;
4304
4305 PROCEDURE validate_contract_process(
4306 p_api_version IN NUMBER,
4307 p_init_msg_list IN VARCHAR2 ,
4308 x_return_status OUT NOCOPY VARCHAR2,
4309 x_msg_count OUT NOCOPY NUMBER,
4310 x_msg_data OUT NOCOPY VARCHAR2,
4311 p_cpsv_rec IN cpsv_rec_type) IS
4312
4313 l_cpsv_rec cpsv_rec_type;
4314 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_PROCESS';
4315 l_api_version CONSTANT NUMBER := 1.0;
4316 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4317 BEGIN
4318 -- call START_ACTIVITY to create savepoint, check compatibility
4319 -- and initialize message list
4320 l_return_status := OKC_API.START_ACTIVITY(
4321 p_api_name => l_api_name,
4322 p_pkg_name => g_pkg_name,
4323 p_init_msg_list => p_init_msg_list,
4324 l_api_version => l_api_version,
4325 p_api_version => p_api_version,
4326 p_api_type => g_api_type,
4327 x_return_status => x_return_status);
4328
4329 -- check if activity started successfully
4330 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4331 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4332 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4333 raise OKC_API.G_EXCEPTION_ERROR;
4334 End If;
4335
4336 -- call BEFORE user hook
4337 l_cpsv_rec := p_cpsv_rec;
4338 g_cpsv_rec := l_cpsv_rec;
4339
4340 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4341 p_package_name => g_pkg_name,
4342 p_procedure_name => l_api_name,
4343 p_before_after => 'B');
4344
4345 -- check return status of user hook call
4346 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4347 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4348 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4349 raise OKC_API.G_EXCEPTION_ERROR;
4350 End If;
4351
4352 -- get values back from user hook call
4353 l_cpsv_rec := g_cpsv_rec;
4354 l_cpsv_rec.id := p_cpsv_rec.id;
4355 l_cpsv_rec.object_version_number := p_cpsv_rec.object_version_number;
4356
4357 -- call procedure in complex API
4358 OKC_CONTRACT_PVT.validate_contract_process(
4359 p_api_version => p_api_version,
4360 p_init_msg_list => p_init_msg_list,
4361 x_return_status => x_return_status,
4362 x_msg_count => x_msg_count,
4363 x_msg_data => x_msg_data,
4364 p_cpsv_rec => l_cpsv_rec);
4365
4366 -- check return status
4367 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4368 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4369 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4370 raise OKC_API.G_EXCEPTION_ERROR;
4371 End If;
4372
4373 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4374 p_package_name => g_pkg_name,
4375 p_procedure_name => l_api_name,
4376 p_before_after => 'A');
4377
4378 -- check return status of the user hook call
4379 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4380 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4381 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4382 raise OKC_API.G_EXCEPTION_ERROR;
4383 End If;
4384
4385 -- end activity
4386 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4387 x_msg_data => x_msg_data);
4388 EXCEPTION
4389 when OKC_API.G_EXCEPTION_ERROR then
4390 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4391 p_api_name => l_api_name,
4392 p_pkg_name => g_pkg_name,
4393 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4394 x_msg_count => x_msg_count,
4395 x_msg_data => x_msg_data,
4396 p_api_type => g_api_type);
4397
4398 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4399 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4400 p_api_name => l_api_name,
4401 p_pkg_name => g_pkg_name,
4402 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4403 x_msg_count => x_msg_count,
4404 x_msg_data => x_msg_data,
4405 p_api_type => g_api_type);
4406
4407 when OTHERS then
4408 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4409 p_api_name => l_api_name,
4410 p_pkg_name => g_pkg_name,
4411 p_exc_name => 'OTHERS',
4412 x_msg_count => x_msg_count,
4413 x_msg_data => x_msg_data,
4414 p_api_type => g_api_type);
4415
4416 END validate_contract_process;
4417
4418 PROCEDURE validate_contract_process(
4419 p_api_version IN NUMBER,
4420 p_init_msg_list IN VARCHAR2 ,
4421 x_return_status OUT NOCOPY VARCHAR2,
4422 x_msg_count OUT NOCOPY NUMBER,
4423 x_msg_data OUT NOCOPY VARCHAR2,
4424 p_cpsv_tbl IN cpsv_tbl_type) IS
4425
4426 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_PROCESS';
4427 l_api_version CONSTANT NUMBER := 1.0;
4428 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4429 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4430 i NUMBER;
4431 BEGIN
4432 -- call START_ACTIVITY to create savepoint, check compatibility
4433 -- and initialize message list
4434 l_return_status := OKC_API.START_ACTIVITY(
4435 p_api_name => l_api_name,
4436 p_pkg_name => g_pkg_name,
4437 p_init_msg_list => p_init_msg_list,
4438 l_api_version => l_api_version,
4439 p_api_version => p_api_version,
4440 p_api_type => g_api_type,
4441 x_return_status => x_return_status);
4442
4443 -- check if activity started successfully
4444 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4445 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4446 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4447 raise OKC_API.G_EXCEPTION_ERROR;
4448 End If;
4449
4450 If (p_cpsv_tbl.COUNT > 0) Then
4451 i := p_cpsv_tbl.FIRST;
4452 LOOP
4453 -- call procedure in complex API
4454 OKC_CONTRACT_PUB.validate_contract_process(
4455 p_api_version => p_api_version,
4456 p_init_msg_list => p_init_msg_list,
4457 x_return_status => x_return_status,
4458 x_msg_count => x_msg_count,
4459 x_msg_data => x_msg_data,
4460 p_cpsv_rec => p_cpsv_tbl(i));
4461
4462 -- store the highest degree of error
4463 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
4464 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
4465 l_overall_status := x_return_status;
4466 End If;
4467 End If;
4468 EXIT WHEN (i = p_cpsv_tbl.LAST);
4469 i := p_cpsv_tbl.NEXT(i);
4470 END LOOP;
4471 -- return overall status
4472 x_return_status := l_overall_status;
4473 End If;
4474
4475 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4476 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4477 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4478 raise OKC_API.G_EXCEPTION_ERROR;
4479 End If;
4480
4481 -- end activity
4482 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4483 x_msg_data => x_msg_data);
4484 EXCEPTION
4485 when OKC_API.G_EXCEPTION_ERROR then
4486 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4487 p_api_name => l_api_name,
4488 p_pkg_name => g_pkg_name,
4489 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4490 x_msg_count => x_msg_count,
4491 x_msg_data => x_msg_data,
4492 p_api_type => g_api_type);
4493
4494 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4495 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4496 p_api_name => l_api_name,
4497 p_pkg_name => g_pkg_name,
4498 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4499 x_msg_count => x_msg_count,
4500 x_msg_data => x_msg_data,
4501 p_api_type => g_api_type);
4502
4503 when OTHERS then
4504 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4505 p_api_name => l_api_name,
4506 p_pkg_name => g_pkg_name,
4507 p_exc_name => 'OTHERS',
4508 x_msg_count => x_msg_count,
4509 x_msg_data => x_msg_data,
4510 p_api_type => g_api_type);
4511
4512 END validate_contract_process;
4513
4514 PROCEDURE create_contract_access(
4515 p_api_version IN NUMBER,
4516 p_init_msg_list IN VARCHAR2 ,
4517 x_return_status OUT NOCOPY VARCHAR2,
4518 x_msg_count OUT NOCOPY NUMBER,
4519 x_msg_data OUT NOCOPY VARCHAR2,
4520 p_cacv_rec IN cacv_rec_type,
4521 x_cacv_rec OUT NOCOPY cacv_rec_type) IS
4522
4523 l_cacv_rec cacv_rec_type;
4524 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_ACCESS';
4525 l_api_version CONSTANT NUMBER := 1.0;
4526 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4527 BEGIN
4528 -- call START_ACTIVITY to create savepoint, check compatibility
4529 -- and initialize message list
4530 l_return_status := OKC_API.START_ACTIVITY(
4531 p_api_name => l_api_name,
4532 p_pkg_name => g_pkg_name,
4533 p_init_msg_list => p_init_msg_list,
4534 l_api_version => l_api_version,
4535 p_api_version => p_api_version,
4536 p_api_type => g_api_type,
4537 x_return_status => x_return_status);
4538
4539 -- check if activity started successfully
4540 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4541 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4542 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4543 raise OKC_API.G_EXCEPTION_ERROR;
4544 End If;
4545
4546 -- call BEFORE user hook
4547 l_cacv_rec := p_cacv_rec;
4548 g_cacv_rec := l_cacv_rec;
4549
4550 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4551 p_package_name => g_pkg_name,
4552 p_procedure_name => l_api_name,
4553 p_before_after => 'B');
4554
4555 -- check return status of user hook call
4556 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4557 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4558 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4559 raise OKC_API.G_EXCEPTION_ERROR;
4560 End If;
4561
4562 -- get values back from user hook call
4563 l_cacv_rec := g_cacv_rec;
4564 l_cacv_rec.id := p_cacv_rec.id;
4565 l_cacv_rec.object_version_number := p_cacv_rec.object_version_number;
4566
4567 -- call procedure in complex API
4568 OKC_CONTRACT_PVT.create_contract_access(
4569 p_api_version => p_api_version,
4570 p_init_msg_list => p_init_msg_list,
4571 x_return_status => x_return_status,
4572 x_msg_count => x_msg_count,
4573 x_msg_data => x_msg_data,
4574 p_cacv_rec => l_cacv_rec,
4575 x_cacv_rec => x_cacv_rec);
4576
4577 -- check return status
4578 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4579 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4580 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4581 raise OKC_API.G_EXCEPTION_ERROR;
4582 End If;
4583
4584 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4585 p_package_name => g_pkg_name,
4586 p_procedure_name => l_api_name,
4587 p_before_after => 'A');
4588
4589 -- check return status of the user hook call
4590 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4591 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4592 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4593 raise OKC_API.G_EXCEPTION_ERROR;
4594 End If;
4595
4596 -- end activity
4597 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4598 x_msg_data => x_msg_data);
4599 EXCEPTION
4600 when OKC_API.G_EXCEPTION_ERROR then
4601 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4602 p_api_name => l_api_name,
4603 p_pkg_name => g_pkg_name,
4604 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4605 x_msg_count => x_msg_count,
4606 x_msg_data => x_msg_data,
4607 p_api_type => g_api_type);
4608
4609 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4610 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4611 p_api_name => l_api_name,
4612 p_pkg_name => g_pkg_name,
4613 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4614 x_msg_count => x_msg_count,
4615 x_msg_data => x_msg_data,
4616 p_api_type => g_api_type);
4617
4618 when OTHERS then
4619 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4620 p_api_name => l_api_name,
4621 p_pkg_name => g_pkg_name,
4622 p_exc_name => 'OTHERS',
4623 x_msg_count => x_msg_count,
4624 x_msg_data => x_msg_data,
4625 p_api_type => g_api_type);
4626
4627 END create_contract_access;
4628
4629 PROCEDURE create_contract_access(
4630 p_api_version IN NUMBER,
4631 p_init_msg_list IN VARCHAR2 ,
4632 x_return_status OUT NOCOPY VARCHAR2,
4633 x_msg_count OUT NOCOPY NUMBER,
4634 x_msg_data OUT NOCOPY VARCHAR2,
4635 p_cacv_tbl IN cacv_tbl_type,
4636 x_cacv_tbl OUT NOCOPY cacv_tbl_type) IS
4637
4638 l_api_name CONSTANT VARCHAR2(30) := 'CREATE_CONTRACT_ACCESS';
4639 l_api_version CONSTANT NUMBER := 1.0;
4640 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4641 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4642 i NUMBER;
4643 BEGIN
4644 -- call START_ACTIVITY to create savepoint, check compatibility
4645 -- and initialize message list
4646 l_return_status := OKC_API.START_ACTIVITY(
4647 p_api_name => l_api_name,
4648 p_pkg_name => g_pkg_name,
4649 p_init_msg_list => p_init_msg_list,
4650 l_api_version => l_api_version,
4651 p_api_version => p_api_version,
4652 p_api_type => g_api_type,
4653 x_return_status => x_return_status);
4654
4655 -- check if activity started successfully
4656 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4657 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4658 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4659 raise OKC_API.G_EXCEPTION_ERROR;
4660 End If;
4661
4662 If (p_cacv_tbl.COUNT > 0) Then
4663 i := p_cacv_tbl.FIRST;
4664 LOOP
4665 -- call procedure in complex API
4666 OKC_CONTRACT_PUB.create_contract_access(
4667 p_api_version => p_api_version,
4668 p_init_msg_list => p_init_msg_list,
4669 x_return_status => x_return_status,
4670 x_msg_count => x_msg_count,
4671 x_msg_data => x_msg_data,
4672 p_cacv_rec => p_cacv_tbl(i),
4673 x_cacv_rec => x_cacv_tbl(i));
4674
4675 -- store the highest degree of error
4676 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
4677 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
4678 l_overall_status := x_return_status;
4679 End If;
4680 End If;
4681 EXIT WHEN (i = p_cacv_tbl.LAST);
4682 i := p_cacv_tbl.NEXT(i);
4683 END LOOP;
4684 -- return overall status
4685 x_return_status := l_overall_status;
4686 End If;
4687
4688 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4689 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4690 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4691 raise OKC_API.G_EXCEPTION_ERROR;
4692 End If;
4693
4694 -- end activity
4695 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4696 x_msg_data => x_msg_data);
4697 EXCEPTION
4698 when OKC_API.G_EXCEPTION_ERROR then
4699 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4700 p_api_name => l_api_name,
4701 p_pkg_name => g_pkg_name,
4702 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4703 x_msg_count => x_msg_count,
4704 x_msg_data => x_msg_data,
4705 p_api_type => g_api_type);
4706
4707 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4708 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4709 p_api_name => l_api_name,
4710 p_pkg_name => g_pkg_name,
4711 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4712 x_msg_count => x_msg_count,
4713 x_msg_data => x_msg_data,
4714 p_api_type => g_api_type);
4715
4716 when OTHERS then
4717 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4718 p_api_name => l_api_name,
4719 p_pkg_name => g_pkg_name,
4720 p_exc_name => 'OTHERS',
4721 x_msg_count => x_msg_count,
4722 x_msg_data => x_msg_data,
4723 p_api_type => g_api_type);
4724
4725 END create_contract_access;
4726
4727 PROCEDURE update_contract_access(
4728 p_api_version IN NUMBER,
4729 p_init_msg_list IN VARCHAR2 ,
4730 x_return_status OUT NOCOPY VARCHAR2,
4731 x_msg_count OUT NOCOPY NUMBER,
4732 x_msg_data OUT NOCOPY VARCHAR2,
4733 p_cacv_rec IN cacv_rec_type,
4734 x_cacv_rec OUT NOCOPY cacv_rec_type) IS
4735
4736 l_cacv_rec cacv_rec_type;
4737 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_ACCESS';
4738 l_api_version CONSTANT NUMBER := 1.0;
4739 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4740 BEGIN
4741 -- call START_ACTIVITY to create savepoint, check compatibility
4742 -- and initialize message list
4743 l_return_status := OKC_API.START_ACTIVITY(
4744 p_api_name => l_api_name,
4745 p_pkg_name => g_pkg_name,
4746 p_init_msg_list => p_init_msg_list,
4747 l_api_version => l_api_version,
4748 p_api_version => p_api_version,
4749 p_api_type => g_api_type,
4750 x_return_status => x_return_status);
4751
4752 -- check if activity started successfully
4753 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4754 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4755 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4756 raise OKC_API.G_EXCEPTION_ERROR;
4757 End If;
4758
4759 -- call BEFORE user hook
4760 l_cacv_rec := p_cacv_rec;
4761 g_cacv_rec := l_cacv_rec;
4762
4763 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4764 p_package_name => g_pkg_name,
4765 p_procedure_name => l_api_name,
4766 p_before_after => 'B');
4767
4768 -- check return status of user hook call
4769 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4770 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4771 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4772 raise OKC_API.G_EXCEPTION_ERROR;
4773 End If;
4774
4775 -- get values back from user hook call
4776 l_cacv_rec := g_cacv_rec;
4777 l_cacv_rec.id := p_cacv_rec.id;
4778 l_cacv_rec.object_version_number := p_cacv_rec.object_version_number;
4779
4780 -- call procedure in complex API
4781 OKC_CONTRACT_PVT.update_contract_access(
4782 p_api_version => p_api_version,
4783 p_init_msg_list => p_init_msg_list,
4784 x_return_status => x_return_status,
4785 x_msg_count => x_msg_count,
4786 x_msg_data => x_msg_data,
4787 p_cacv_rec => l_cacv_rec,
4788 x_cacv_rec => x_cacv_rec);
4789
4790 -- check return status
4791 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4792 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4793 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4794 raise OKC_API.G_EXCEPTION_ERROR;
4795 End If;
4796
4797 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4798 p_package_name => g_pkg_name,
4799 p_procedure_name => l_api_name,
4800 p_before_after => 'A');
4801
4802 -- check return status of the user hook call
4803 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4804 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4805 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4806 raise OKC_API.G_EXCEPTION_ERROR;
4807 End If;
4808
4809 -- end activity
4810 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4811 x_msg_data => x_msg_data);
4812 EXCEPTION
4813 when OKC_API.G_EXCEPTION_ERROR then
4814 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4815 p_api_name => l_api_name,
4816 p_pkg_name => g_pkg_name,
4817 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4818 x_msg_count => x_msg_count,
4819 x_msg_data => x_msg_data,
4820 p_api_type => g_api_type);
4821
4822 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4823 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4824 p_api_name => l_api_name,
4825 p_pkg_name => g_pkg_name,
4826 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4827 x_msg_count => x_msg_count,
4828 x_msg_data => x_msg_data,
4829 p_api_type => g_api_type);
4830
4831 when OTHERS then
4832 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4833 p_api_name => l_api_name,
4834 p_pkg_name => g_pkg_name,
4835 p_exc_name => 'OTHERS',
4836 x_msg_count => x_msg_count,
4837 x_msg_data => x_msg_data,
4838 p_api_type => g_api_type);
4839
4840 END update_contract_access;
4841
4842 PROCEDURE update_contract_access(
4843 p_api_version IN NUMBER,
4844 p_init_msg_list IN VARCHAR2 ,
4845 x_return_status OUT NOCOPY VARCHAR2,
4846 x_msg_count OUT NOCOPY NUMBER,
4847 x_msg_data OUT NOCOPY VARCHAR2,
4848 p_cacv_tbl IN cacv_tbl_type,
4849 x_cacv_tbl OUT NOCOPY cacv_tbl_type) IS
4850
4851 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_CONTRACT_ACCESS';
4852 l_api_version CONSTANT NUMBER := 1.0;
4853 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4854 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4855 i NUMBER;
4856 BEGIN
4857 -- call START_ACTIVITY to create savepoint, check compatibility
4858 -- and initialize message list
4859 l_return_status := OKC_API.START_ACTIVITY(
4860 p_api_name => l_api_name,
4861 p_pkg_name => g_pkg_name,
4862 p_init_msg_list => p_init_msg_list,
4863 l_api_version => l_api_version,
4864 p_api_version => p_api_version,
4865 p_api_type => g_api_type,
4866 x_return_status => x_return_status);
4867
4868 -- check if activity started successfully
4869 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4870 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4871 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4872 raise OKC_API.G_EXCEPTION_ERROR;
4873 End If;
4874
4875 If (p_cacv_tbl.COUNT > 0) Then
4876 i := p_cacv_tbl.FIRST;
4877 LOOP
4878 -- call procedure in complex API
4879 OKC_CONTRACT_PUB.update_contract_access(
4880 p_api_version => p_api_version,
4881 p_init_msg_list => p_init_msg_list,
4882 x_return_status => x_return_status,
4883 x_msg_count => x_msg_count,
4884 x_msg_data => x_msg_data,
4885 p_cacv_rec => p_cacv_tbl(i),
4886 x_cacv_rec => x_cacv_tbl(i));
4887
4888 -- store the highest degree of error
4889 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
4890 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
4891 l_overall_status := x_return_status;
4892 End If;
4893 End If;
4894 EXIT WHEN (i = p_cacv_tbl.LAST);
4895 i := p_cacv_tbl.NEXT(i);
4896 END LOOP;
4897 -- return overall status
4898 x_return_status := l_overall_status;
4899 End If;
4900
4901 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4902 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4903 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4904 raise OKC_API.G_EXCEPTION_ERROR;
4905 End If;
4906
4907 -- end activity
4908 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
4909 x_msg_data => x_msg_data);
4910 EXCEPTION
4911 when OKC_API.G_EXCEPTION_ERROR then
4912 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4913 p_api_name => l_api_name,
4914 p_pkg_name => g_pkg_name,
4915 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
4916 x_msg_count => x_msg_count,
4917 x_msg_data => x_msg_data,
4918 p_api_type => g_api_type);
4919
4920 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
4921 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4922 p_api_name => l_api_name,
4923 p_pkg_name => g_pkg_name,
4924 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
4925 x_msg_count => x_msg_count,
4926 x_msg_data => x_msg_data,
4927 p_api_type => g_api_type);
4928
4929 when OTHERS then
4930 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
4931 p_api_name => l_api_name,
4932 p_pkg_name => g_pkg_name,
4933 p_exc_name => 'OTHERS',
4934 x_msg_count => x_msg_count,
4935 x_msg_data => x_msg_data,
4936 p_api_type => g_api_type);
4937
4938 END update_contract_access;
4939
4940 PROCEDURE delete_contract_access(
4941 p_api_version IN NUMBER,
4942 p_init_msg_list IN VARCHAR2 ,
4943 x_return_status OUT NOCOPY VARCHAR2,
4944 x_msg_count OUT NOCOPY NUMBER,
4945 x_msg_data OUT NOCOPY VARCHAR2,
4946 p_cacv_rec IN cacv_rec_type) IS
4947
4948 l_cacv_rec cacv_rec_type;
4949 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_ACCESS';
4950 l_api_version CONSTANT NUMBER := 1.0;
4951 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4952 BEGIN
4953 -- call START_ACTIVITY to create savepoint, check compatibility
4954 -- and initialize message list
4955 l_return_status := OKC_API.START_ACTIVITY(
4956 p_api_name => l_api_name,
4957 p_pkg_name => g_pkg_name,
4958 p_init_msg_list => p_init_msg_list,
4959 l_api_version => l_api_version,
4960 p_api_version => p_api_version,
4961 p_api_type => g_api_type,
4962 x_return_status => x_return_status);
4963
4964 -- check if activity started successfully
4965 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
4966 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4967 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
4968 raise OKC_API.G_EXCEPTION_ERROR;
4969 End If;
4970
4971 -- call BEFORE user hook
4972 l_cacv_rec := p_cacv_rec;
4973 g_cacv_rec := l_cacv_rec;
4974
4975 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
4976 p_package_name => g_pkg_name,
4977 p_procedure_name => l_api_name,
4978 p_before_after => 'B');
4979
4980 -- check return status of user hook call
4981 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
4982 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4983 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
4984 raise OKC_API.G_EXCEPTION_ERROR;
4985 End If;
4986
4987 -- get values back from user hook call
4988 l_cacv_rec := g_cacv_rec;
4989 l_cacv_rec.id := p_cacv_rec.id;
4990 l_cacv_rec.object_version_number := p_cacv_rec.object_version_number;
4991
4992 -- call procedure in complex API
4993 OKC_CONTRACT_PVT.delete_contract_access(
4994 p_api_version => p_api_version,
4995 p_init_msg_list => p_init_msg_list,
4996 x_return_status => x_return_status,
4997 x_msg_count => x_msg_count,
4998 x_msg_data => x_msg_data,
4999 p_cacv_rec => l_cacv_rec);
5000
5001 -- check return status
5002 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5003 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5004 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5005 raise OKC_API.G_EXCEPTION_ERROR;
5006 End If;
5007
5008 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
5009 p_package_name => g_pkg_name,
5010 p_procedure_name => l_api_name,
5011 p_before_after => 'A');
5012
5013 -- check return status of the user hook call
5014 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5015 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5016 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5017 raise OKC_API.G_EXCEPTION_ERROR;
5018 End If;
5019
5020 -- end activity
5021 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
5022 x_msg_data => x_msg_data);
5023 EXCEPTION
5024 when OKC_API.G_EXCEPTION_ERROR then
5025 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5026 p_api_name => l_api_name,
5027 p_pkg_name => g_pkg_name,
5028 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
5029 x_msg_count => x_msg_count,
5030 x_msg_data => x_msg_data,
5031 p_api_type => g_api_type);
5032
5033 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
5034 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5035 p_api_name => l_api_name,
5036 p_pkg_name => g_pkg_name,
5037 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
5038 x_msg_count => x_msg_count,
5039 x_msg_data => x_msg_data,
5040 p_api_type => g_api_type);
5041
5042 when OTHERS then
5043 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5044 p_api_name => l_api_name,
5045 p_pkg_name => g_pkg_name,
5046 p_exc_name => 'OTHERS',
5047 x_msg_count => x_msg_count,
5048 x_msg_data => x_msg_data,
5049 p_api_type => g_api_type);
5050
5051 END delete_contract_access;
5052
5053 PROCEDURE delete_contract_access(
5054 p_api_version IN NUMBER,
5055 p_init_msg_list IN VARCHAR2 ,
5056 x_return_status OUT NOCOPY VARCHAR2,
5057 x_msg_count OUT NOCOPY NUMBER,
5058 x_msg_data OUT NOCOPY VARCHAR2,
5059 p_cacv_tbl IN cacv_tbl_type) IS
5060
5061 l_api_name CONSTANT VARCHAR2(30) := 'DELETE_CONTRACT_ACCESS';
5062 l_api_version CONSTANT NUMBER := 1.0;
5063 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5064 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5065 i NUMBER;
5066 BEGIN
5067 -- call START_ACTIVITY to create savepoint, check compatibility
5068 -- and initialize message list
5069 l_return_status := OKC_API.START_ACTIVITY(
5070 p_api_name => l_api_name,
5071 p_pkg_name => g_pkg_name,
5072 p_init_msg_list => p_init_msg_list,
5073 l_api_version => l_api_version,
5074 p_api_version => p_api_version,
5075 p_api_type => g_api_type,
5076 x_return_status => x_return_status);
5077
5078 -- check if activity started successfully
5079 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
5080 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5081 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
5082 raise OKC_API.G_EXCEPTION_ERROR;
5083 End If;
5084
5085 If (p_cacv_tbl.COUNT > 0) Then
5086 i := p_cacv_tbl.FIRST;
5087 LOOP
5088 -- call procedure in complex API
5089 OKC_CONTRACT_PUB.delete_contract_access(
5090 p_api_version => p_api_version,
5091 p_init_msg_list => p_init_msg_list,
5092 x_return_status => x_return_status,
5093 x_msg_count => x_msg_count,
5094 x_msg_data => x_msg_data,
5095 p_cacv_rec => p_cacv_tbl(i));
5096
5097 -- store the highest degree of error
5098 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
5099 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
5100 l_overall_status := x_return_status;
5101 End If;
5102 End If;
5103 EXIT WHEN (i = p_cacv_tbl.LAST);
5104 i := p_cacv_tbl.NEXT(i);
5105 END LOOP;
5106 -- return overall status
5107 x_return_status := l_overall_status;
5108 End If;
5109
5110 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5111 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5112 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5113 raise OKC_API.G_EXCEPTION_ERROR;
5114 End If;
5115
5116 -- end activity
5117 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
5118 x_msg_data => x_msg_data);
5119 EXCEPTION
5120 when OKC_API.G_EXCEPTION_ERROR then
5121 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5122 p_api_name => l_api_name,
5123 p_pkg_name => g_pkg_name,
5124 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
5125 x_msg_count => x_msg_count,
5126 x_msg_data => x_msg_data,
5127 p_api_type => g_api_type);
5128
5129 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
5130 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5131 p_api_name => l_api_name,
5132 p_pkg_name => g_pkg_name,
5133 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
5134 x_msg_count => x_msg_count,
5135 x_msg_data => x_msg_data,
5136 p_api_type => g_api_type);
5137
5138 when OTHERS then
5139 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5140 p_api_name => l_api_name,
5141 p_pkg_name => g_pkg_name,
5142 p_exc_name => 'OTHERS',
5143 x_msg_count => x_msg_count,
5144 x_msg_data => x_msg_data,
5145 p_api_type => g_api_type);
5146
5147 END delete_contract_access;
5148
5149 PROCEDURE lock_contract_access(
5150 p_api_version IN NUMBER,
5151 p_init_msg_list IN VARCHAR2 ,
5152 x_return_status OUT NOCOPY VARCHAR2,
5153 x_msg_count OUT NOCOPY NUMBER,
5154 x_msg_data OUT NOCOPY VARCHAR2,
5155 p_cacv_rec IN cacv_rec_type) IS
5156
5157 l_cacv_rec cacv_rec_type;
5158 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_ACCESS';
5159 l_api_version CONSTANT NUMBER := 1.0;
5160 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5161 BEGIN
5162 -- call START_ACTIVITY to create savepoint, check compatibility
5163 -- and initialize message list
5164 l_return_status := OKC_API.START_ACTIVITY(
5165 p_api_name => l_api_name,
5166 p_pkg_name => g_pkg_name,
5167 p_init_msg_list => p_init_msg_list,
5168 l_api_version => l_api_version,
5169 p_api_version => p_api_version,
5170 p_api_type => g_api_type,
5171 x_return_status => x_return_status);
5172
5173 -- check if activity started successfully
5174 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
5175 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5176 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
5177 raise OKC_API.G_EXCEPTION_ERROR;
5178 End If;
5179
5180 -- call BEFORE user hook
5181 l_cacv_rec := p_cacv_rec;
5182 g_cacv_rec := l_cacv_rec;
5183
5184 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
5185 p_package_name => g_pkg_name,
5186 p_procedure_name => l_api_name,
5187 p_before_after => 'B');
5188
5189 -- check return status of user hook call
5190 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5191 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5192 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5193 raise OKC_API.G_EXCEPTION_ERROR;
5194 End If;
5195
5196 -- get values back from user hook call
5197 l_cacv_rec := g_cacv_rec;
5198 l_cacv_rec.id := p_cacv_rec.id;
5199 l_cacv_rec.object_version_number := p_cacv_rec.object_version_number;
5200
5201 -- call procedure in complex API
5202 OKC_CONTRACT_PVT.lock_contract_access(
5203 p_api_version => p_api_version,
5204 p_init_msg_list => p_init_msg_list,
5205 x_return_status => x_return_status,
5206 x_msg_count => x_msg_count,
5207 x_msg_data => x_msg_data,
5208 p_cacv_rec => l_cacv_rec);
5209
5210 -- check return status
5211 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5212 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5213 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5214 raise OKC_API.G_EXCEPTION_ERROR;
5215 End If;
5216
5217 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
5218 p_package_name => g_pkg_name,
5219 p_procedure_name => l_api_name,
5220 p_before_after => 'A');
5221
5222 -- check return status of the user hook call
5223 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5224 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5225 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5226 raise OKC_API.G_EXCEPTION_ERROR;
5227 End If;
5228
5229 -- end activity
5230 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
5231 x_msg_data => x_msg_data);
5232 EXCEPTION
5233 when OKC_API.G_EXCEPTION_ERROR then
5234 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5235 p_api_name => l_api_name,
5236 p_pkg_name => g_pkg_name,
5237 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
5238 x_msg_count => x_msg_count,
5239 x_msg_data => x_msg_data,
5240 p_api_type => g_api_type);
5241
5242 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
5243 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5244 p_api_name => l_api_name,
5245 p_pkg_name => g_pkg_name,
5246 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
5247 x_msg_count => x_msg_count,
5248 x_msg_data => x_msg_data,
5249 p_api_type => g_api_type);
5250
5251 when OTHERS then
5252 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5253 p_api_name => l_api_name,
5254 p_pkg_name => g_pkg_name,
5255 p_exc_name => 'OTHERS',
5256 x_msg_count => x_msg_count,
5257 x_msg_data => x_msg_data,
5258 p_api_type => g_api_type);
5259
5260 END lock_contract_access;
5261
5262 PROCEDURE lock_contract_access(
5263 p_api_version IN NUMBER,
5264 p_init_msg_list IN VARCHAR2 ,
5265 x_return_status OUT NOCOPY VARCHAR2,
5266 x_msg_count OUT NOCOPY NUMBER,
5267 x_msg_data OUT NOCOPY VARCHAR2,
5268 p_cacv_tbl IN cacv_tbl_type) IS
5269
5270 l_api_name CONSTANT VARCHAR2(30) := 'LOCK_CONTRACT_ACCESS';
5271 l_api_version CONSTANT NUMBER := 1.0;
5272 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5273 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5274 i NUMBER;
5275 BEGIN
5276 -- call START_ACTIVITY to create savepoint, check compatibility
5277 -- and initialize message list
5278 l_return_status := OKC_API.START_ACTIVITY(
5279 p_api_name => l_api_name,
5280 p_pkg_name => g_pkg_name,
5281 p_init_msg_list => p_init_msg_list,
5282 l_api_version => l_api_version,
5283 p_api_version => p_api_version,
5284 p_api_type => g_api_type,
5285 x_return_status => x_return_status);
5286
5287 -- check if activity started successfully
5288 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
5289 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5290 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
5291 raise OKC_API.G_EXCEPTION_ERROR;
5292 End If;
5293
5294 If (p_cacv_tbl.COUNT > 0) Then
5295 i := p_cacv_tbl.FIRST;
5296 LOOP
5297 -- call procedure in complex API
5298 OKC_CONTRACT_PUB.lock_contract_access(
5299 p_api_version => p_api_version,
5300 p_init_msg_list => p_init_msg_list,
5301 x_return_status => x_return_status,
5302 x_msg_count => x_msg_count,
5303 x_msg_data => x_msg_data,
5304 p_cacv_rec => p_cacv_tbl(i));
5305
5306 -- store the highest degree of error
5307 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
5308 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
5309 l_overall_status := x_return_status;
5310 End If;
5311 End If;
5312 EXIT WHEN (i = p_cacv_tbl.LAST);
5313 i := p_cacv_tbl.NEXT(i);
5314 END LOOP;
5315 -- return overall status
5316 x_return_status := l_overall_status;
5317 End If;
5318
5319 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5320 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5321 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5322 raise OKC_API.G_EXCEPTION_ERROR;
5323 End If;
5324
5325 -- end activity
5326 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
5327 x_msg_data => x_msg_data);
5328 EXCEPTION
5329 when OKC_API.G_EXCEPTION_ERROR then
5330 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5331 p_api_name => l_api_name,
5332 p_pkg_name => g_pkg_name,
5333 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
5334 x_msg_count => x_msg_count,
5335 x_msg_data => x_msg_data,
5336 p_api_type => g_api_type);
5337
5338 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
5339 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5340 p_api_name => l_api_name,
5341 p_pkg_name => g_pkg_name,
5342 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
5343 x_msg_count => x_msg_count,
5344 x_msg_data => x_msg_data,
5345 p_api_type => g_api_type);
5346
5347 when OTHERS then
5348 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5349 p_api_name => l_api_name,
5350 p_pkg_name => g_pkg_name,
5351 p_exc_name => 'OTHERS',
5352 x_msg_count => x_msg_count,
5353 x_msg_data => x_msg_data,
5354 p_api_type => g_api_type);
5355
5356 END lock_contract_access;
5357
5358 PROCEDURE validate_contract_access(
5359 p_api_version IN NUMBER,
5360 p_init_msg_list IN VARCHAR2 ,
5361 x_return_status OUT NOCOPY VARCHAR2,
5362 x_msg_count OUT NOCOPY NUMBER,
5363 x_msg_data OUT NOCOPY VARCHAR2,
5364 p_cacv_rec IN cacv_rec_type) IS
5365
5366 l_cacv_rec cacv_rec_type;
5367 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_ACCESS';
5368 l_api_version CONSTANT NUMBER := 1.0;
5369 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5370 BEGIN
5371 -- call START_ACTIVITY to create savepoint, check compatibility
5372 -- and initialize message list
5373 l_return_status := OKC_API.START_ACTIVITY(
5374 p_api_name => l_api_name,
5375 p_pkg_name => g_pkg_name,
5376 p_init_msg_list => p_init_msg_list,
5377 l_api_version => l_api_version,
5378 p_api_version => p_api_version,
5379 p_api_type => g_api_type,
5380 x_return_status => x_return_status);
5381
5382 -- check if activity started successfully
5383 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
5384 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5385 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
5386 raise OKC_API.G_EXCEPTION_ERROR;
5387 End If;
5388
5389 -- call BEFORE user hook
5390 l_cacv_rec := p_cacv_rec;
5391 g_cacv_rec := l_cacv_rec;
5392
5393 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
5394 p_package_name => g_pkg_name,
5395 p_procedure_name => l_api_name,
5396 p_before_after => 'B');
5397
5398 -- check return status of user hook call
5399 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5400 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5401 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5402 raise OKC_API.G_EXCEPTION_ERROR;
5403 End If;
5404
5405 -- get values back from user hook call
5406 l_cacv_rec := g_cacv_rec;
5407 l_cacv_rec.id := p_cacv_rec.id;
5408 l_cacv_rec.object_version_number := p_cacv_rec.object_version_number;
5409
5410 -- call procedure in complex API
5411 OKC_CONTRACT_PVT.validate_contract_access(
5412 p_api_version => p_api_version,
5413 p_init_msg_list => p_init_msg_list,
5414 x_return_status => x_return_status,
5415 x_msg_count => x_msg_count,
5416 x_msg_data => x_msg_data,
5417 p_cacv_rec => l_cacv_rec);
5418
5419 -- check return status
5420 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5421 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5422 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5423 raise OKC_API.G_EXCEPTION_ERROR;
5424 End If;
5425
5426 OKC_UTIL.call_user_hook(x_return_status => x_return_status,
5427 p_package_name => g_pkg_name,
5428 p_procedure_name => l_api_name,
5429 p_before_after => 'A');
5430
5431 -- check return status of the user hook call
5432 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5433 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5434 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5435 raise OKC_API.G_EXCEPTION_ERROR;
5436 End If;
5437
5438 -- end activity
5439 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
5440 x_msg_data => x_msg_data);
5441 EXCEPTION
5442 when OKC_API.G_EXCEPTION_ERROR then
5443 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5444 p_api_name => l_api_name,
5445 p_pkg_name => g_pkg_name,
5446 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
5447 x_msg_count => x_msg_count,
5448 x_msg_data => x_msg_data,
5449 p_api_type => g_api_type);
5450
5451 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
5452 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5453 p_api_name => l_api_name,
5454 p_pkg_name => g_pkg_name,
5455 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
5456 x_msg_count => x_msg_count,
5457 x_msg_data => x_msg_data,
5458 p_api_type => g_api_type);
5459
5460 when OTHERS then
5461 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5462 p_api_name => l_api_name,
5463 p_pkg_name => g_pkg_name,
5464 p_exc_name => 'OTHERS',
5465 x_msg_count => x_msg_count,
5466 x_msg_data => x_msg_data,
5467 p_api_type => g_api_type);
5468
5469 END validate_contract_access;
5470
5471 PROCEDURE validate_contract_access(
5472 p_api_version IN NUMBER,
5473 p_init_msg_list IN VARCHAR2 ,
5474 x_return_status OUT NOCOPY VARCHAR2,
5475 x_msg_count OUT NOCOPY NUMBER,
5476 x_msg_data OUT NOCOPY VARCHAR2,
5477 p_cacv_tbl IN cacv_tbl_type) IS
5478
5479 l_api_name CONSTANT VARCHAR2(30) := 'VALIDATE_CONTRACT_ACCESS';
5480 l_api_version CONSTANT NUMBER := 1.0;
5481 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5482 l_overall_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5483 i NUMBER;
5484 BEGIN
5485 -- call START_ACTIVITY to create savepoint, check compatibility
5486 -- and initialize message list
5487 l_return_status := OKC_API.START_ACTIVITY(
5488 p_api_name => l_api_name,
5489 p_pkg_name => g_pkg_name,
5490 p_init_msg_list => p_init_msg_list,
5491 l_api_version => l_api_version,
5492 p_api_version => p_api_version,
5493 p_api_type => g_api_type,
5494 x_return_status => x_return_status);
5495
5496 -- check if activity started successfully
5497 If (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
5498 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5499 Elsif (l_return_status = OKC_API.G_RET_STS_ERROR) then
5500 raise OKC_API.G_EXCEPTION_ERROR;
5501 End If;
5502
5503 If (p_cacv_tbl.COUNT > 0) Then
5504 i := p_cacv_tbl.FIRST;
5505 LOOP
5506 -- call procedure in complex API
5507 OKC_CONTRACT_PUB.validate_contract_access(
5508 p_api_version => p_api_version,
5509 p_init_msg_list => p_init_msg_list,
5510 x_return_status => x_return_status,
5511 x_msg_count => x_msg_count,
5512 x_msg_data => x_msg_data,
5513 p_cacv_rec => p_cacv_tbl(i));
5514
5515 -- store the highest degree of error
5516 If x_return_status <> OKC_API.G_RET_STS_SUCCESS Then
5517 If l_overall_status <> OKC_API.G_RET_STS_UNEXP_ERROR Then
5518 l_overall_status := x_return_status;
5519 End If;
5520 End If;
5521 EXIT WHEN (i = p_cacv_tbl.LAST);
5522 i := p_cacv_tbl.NEXT(i);
5523 END LOOP;
5524 -- return overall status
5525 x_return_status := l_overall_status;
5526 End If;
5527
5528 If x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
5529 raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5530 Elsif x_return_status = OKC_API.G_RET_STS_ERROR Then
5531 raise OKC_API.G_EXCEPTION_ERROR;
5532 End If;
5533
5534 -- end activity
5535 OKC_API.END_ACTIVITY( x_msg_count => x_msg_count,
5536 x_msg_data => x_msg_data);
5537 EXCEPTION
5538 when OKC_API.G_EXCEPTION_ERROR then
5539 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5540 p_api_name => l_api_name,
5541 p_pkg_name => g_pkg_name,
5542 p_exc_name => 'OKC_API.G_RET_STS_ERROR',
5543 x_msg_count => x_msg_count,
5544 x_msg_data => x_msg_data,
5545 p_api_type => g_api_type);
5546
5547 when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
5548 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5549 p_api_name => l_api_name,
5550 p_pkg_name => g_pkg_name,
5551 p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
5552 x_msg_count => x_msg_count,
5553 x_msg_data => x_msg_data,
5554 p_api_type => g_api_type);
5555
5556 when OTHERS then
5557 x_return_status := OKC_API.HANDLE_EXCEPTIONS(
5558 p_api_name => l_api_name,
5559 p_pkg_name => g_pkg_name,
5560 p_exc_name => 'OTHERS',
5561 x_msg_count => x_msg_count,
5562 x_msg_data => x_msg_data,
5563 p_api_type => g_api_type);
5564
5565 END validate_contract_access;
5566
5567 PROCEDURE add_language IS
5568 l_api_name CONSTANT VARCHAR2(30) := 'ADD_LANGUAGE';
5569 l_api_version CONSTANT NUMBER := 1.0;
5570 l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5571 x_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5572 BEGIN
5573
5574 -- call procedure in complex API
5575 OKC_CONTRACT_PVT.add_language;
5576
5577 END add_language;
5578
5579 PROCEDURE Get_Active_Process (
5580 p_api_version IN NUMBER,
5581 p_init_msg_list IN VARCHAR2,
5582 x_return_status OUT NOCOPY VARCHAR2,
5583 x_msg_count OUT NOCOPY NUMBER,
5584 x_msg_data OUT NOCOPY VARCHAR2,
5585 p_contract_number IN VARCHAR2,
5586 p_contract_number_modifier IN VARCHAR2,
5587 x_wf_name OUT NOCOPY VARCHAR2,
5588 x_wf_process_name OUT NOCOPY VARCHAR2,
5589 x_package_name OUT NOCOPY VARCHAR2,
5590 x_procedure_name OUT NOCOPY VARCHAR2,
5591 x_usage OUT NOCOPY VARCHAR2) Is
5592 BEGIN
5593 OKC_CONTRACT_PVT.Get_Active_Process (
5594 p_api_version => p_api_version,
5595 p_init_msg_list => p_init_msg_list,
5596 x_return_status => x_return_status,
5597 x_msg_count => x_msg_count,
5598 x_msg_data => x_msg_data,
5599 p_contract_number => p_contract_number,
5600 p_contract_number_modifier => p_contract_number_modifier,
5601 x_wf_name => x_wf_name,
5602 x_wf_process_name => x_wf_process_name,
5603 x_package_name => x_package_name,
5604 x_procedure_name => x_procedure_name,
5605 x_usage => x_usage);
5606 END Get_Active_Process;
5607
5608 FUNCTION Update_Allowed(p_chr_id IN NUMBER) RETURN VARCHAR2 Is
5609 BEGIN
5610 return (OKC_CONTRACT_PVT.Update_Allowed(p_chr_id));
5611 END Update_Allowed;
5612
5613 PROCEDURE Initialize(x_chrv_tbl OUT NOCOPY chrv_tbl_type) IS
5614 BEGIN
5615 x_chrv_tbl(1).created_by := OKC_API.G_MISS_NUM; --just touch
5616 END;
5617
5618 PROCEDURE Initialize(x_clev_tbl OUT NOCOPY clev_tbl_type) IS
5619 BEGIN
5620 x_clev_tbl(1).created_by := OKC_API.G_MISS_NUM; --just touch
5621 END;
5622
5623 PROCEDURE Initialize(x_cpsv_tbl OUT NOCOPY cpsv_tbl_type) IS
5624 BEGIN
5625 x_cpsv_tbl(1).created_by := OKC_API.G_MISS_NUM; --just touch
5626 END;
5627
5628 PROCEDURE Initialize(x_cacv_tbl OUT NOCOPY cacv_tbl_type) IS
5629 BEGIN
5630 x_cacv_tbl(1).created_by := OKC_API.G_MISS_NUM; --just touch
5631 END;
5632
5633 PROCEDURE Initialize(x_gvev_tbl OUT NOCOPY gvev_tbl_type) IS
5634 BEGIN
5635 x_gvev_tbl(1).created_by := OKC_API.G_MISS_NUM; --just touch
5636 END;
5637
5638 PROCEDURE Initialize(x_cvmv_tbl OUT NOCOPY cvmv_tbl_type) IS
5639 BEGIN
5640 x_cvmv_tbl(1).created_by := OKC_API.G_MISS_NUM; --just touch
5641 END;
5642
5643 FUNCTION Increment_Minor_Version(p_chr_id IN NUMBER) RETURN VARCHAR2 IS
5644 BEGIN
5645 return OKC_CONTRACT_PVT.Increment_Minor_Version(p_chr_id);
5646 END;
5647
5648 --For Bug.No.1789860, Function Get_concat_line_no is added.
5649 FUNCTION Get_concat_line_no(p_cle_id IN NUMBER,x_return_status OUT NOCOPY VARCHAR2) RETURN VARCHAR2 IS
5650 BEGIN
5651 return(OKC_CONTRACT_PVT.Get_concat_line_no(p_cle_id, x_return_status));
5652 END;
5653
5654
5655 -------
5656 -- Bug 4314347 --
5657 -- GCHADHA --
5658
5659
5660
5661 Procedure update_lines(p_id in number,
5662 p_sts_code in varchar2,
5663 p_new_ste_code in VARCHAR2,
5664 p_old_ste_code in VARCHAR2,
5665 p_ste_code in VARCHAR2,
5666 x_return_status OUT NOCOPY BOOLEAN) IS
5667
5668 x_num number;
5669 l_clev_tbl clev_tbl_type;
5670 l1_clev_tbl clev_tbl_type;
5671 Type Num_Tbl_Type is table of NUMBER index by BINARY_INTEGER ;
5672 TYPE VC30_Tbl_Type is TABLE of VARCHAR2(30) index by BINARY_INTEGER ;
5673 b_Tbl VC30_Tbl_Type;
5674 a_Tbl Num_Tbl_Type;
5675 l_type varchar2(30);
5676 l_line_update varchar2(1) := 'Y';
5677 l_return_status varchar2(1) := 'S';
5678 l_init_msg_list varchar2(1) := 'T';
5679 l_msg_count NUMBER;
5680 l_msg_data varchar2(240);
5681 p_count NUMBER;
5682
5683 --
5684 cursor c_type is
5685 select ste_code
5686 from okc_statuses_v
5687 where code=p_sts_code;
5688 --
5689 l_signed varchar2(30);
5690 --
5691 cursor c_signed is
5692 select code
5693 from okc_statuses_v
5694 where ste_code='SIGNED'
5695 and default_yn='Y';
5696 --
5697 l_expired varchar2(30);
5698 --
5699 cursor c_expired is
5700 select code
5701 from okc_statuses_v
5702 where ste_code='EXPIRED'
5703 and default_yn='Y';
5704 --
5705 cursor c_lines is
5706 select L.id, decode(l_type,'ACTIVE',
5707 decode(sign(months_between(sysdate-1,NVL(L.end_date,sysdate))),-1,
5708 decode(sign(months_between(L.start_date-1,sysdate)),-1,p_sts_code,l_signed)
5709 ,l_expired)
5710 ,p_sts_code) code
5711 from okc_k_headers_v H, okc_k_lines_v L, okc_statuses_v S
5712 where H.id= p_id
5713 and L.dnz_chr_id = p_id
5714 and S.code = L.sts_code
5715 and S.ste_code in ('ENTERED','CANCELLED','ACTIVE','SIGNED','HOLD');
5716
5717 PROCEDURE init_table(x_clev_tbl out NOCOPY clev_tbl_type) IS
5718 g_clev_tbl clev_tbl_type;
5719 BEGIN
5720 x_clev_tbl := g_clev_tbl;
5721 END;
5722 --g_api_version constant number :=1;
5723
5724 --
5725 Begin
5726 open c_type;
5727 fetch c_type into l_type;
5728
5729 close c_type;
5730 If (l_type='ACTIVE') then
5731 open c_signed;
5732 fetch c_signed into l_signed;
5733 close c_signed;
5734 open c_expired;
5735 fetch c_expired into l_expired;
5736 close c_expired;
5737 End If;
5738 --
5739 x_num := 0;
5740 init_table(l_clev_tbl);
5741 open c_lines;
5742 LOOP
5743
5744 FETCH c_lines BULK COLLECT INTO
5745 a_tbl,
5746 b_tbl
5747 LIMIT 1000 ;
5748 IF (a_Tbl.COUNT < 1) THEN
5749 EXIT;
5750 END IF;
5751
5752 IF (a_tbl.COUNT > 0) THEN
5753 FOR i IN a_Tbl.FIRST .. a_Tbl.LAST LOOP
5754 l_clev_tbl(x_num).id := a_tbl(i);
5755 l_clev_tbl(x_num).sts_code := b_tbl(i);
5756 -- To prevent Action Assembler from being called. Changes is line status
5757 -- will always result from a change in the header status
5758 --
5759 l_clev_tbl(x_num).VALIDATE_YN := 'N';
5760
5761 l_clev_tbl(x_num).call_action_asmblr := 'N';
5762 If NVL(P_STE_CODE,'X') = 'CANCELLED' then
5763 l_clev_tbl(x_num).new_ste_code := p_new_ste_code ;
5764 l_clev_tbl(x_num).old_ste_code := p_old_ste_code ;
5765 End if;
5766 x_num :=x_num+1;
5767 END LOOP;
5768 END IF;
5769 exit when c_lines%NOTFOUND;
5770 END LOOP;
5771 close c_lines;
5772 --
5773
5774 OKC_CONTRACT_PUB.update_contract_line(
5775 p_api_version => 1,
5776 P_INIT_MSG_LIST => 'T',
5777 p_restricted_update => 'T',
5778 x_return_status => l_return_status,
5779 x_msg_count => l_msg_count,
5780 x_msg_data => l_msg_data,
5781 p_clev_tbl => l_clev_tbl,
5782 x_clev_tbl => l1_clev_tbl);
5783
5784 If (l_return_status <> 'S') then
5785 l_line_update := 'N';
5786 End if;
5787
5788
5789 If l_line_update = 'Y' then
5790 x_return_status :=TRUE;
5791 Else
5792 x_return_status := FALSE;
5793 End If;
5794 EXCEPTION when others then
5795 If c_lines%ISOPEN then close c_lines;
5796 end if;
5797 raise;
5798 END update_lines;
5799
5800
5801
5802
5803 --------
5804
5805 END OKC_CONTRACT_PUB;